gcc/cp/decl.c

   1 /* Process declarations and variables for C compiler.
   2    Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000
   3    Free Software Foundation, Inc.
   4    Contributed by Michael Tiemann (tiemann@cygnus.com)
   5
   6 This file is part of GNU CC.
   7
   8 GNU CC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2, or (at your option)
  11 any later version.
  12
  13 GNU CC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GNU CC; see the file COPYING.  If not, write to
  20 the Free Software Foundation, 59 Temple Place - Suite 330,
  21 Boston, MA 02111-1307, USA.  */
  22
  23
  24 /* Process declarations and symbol lookup for C front end.
  25    Also constructs types; the standard scalar types at initialization,
  26    and structure, union, array and enum types when they are declared.  */
  27
  28 /* ??? not all decl nodes are given the most useful possible
  29    line numbers.  For example, the CONST_DECLs for enum values.  */
  30
  31 #include "config.h"
  32 #include "system.h"
  33 #include "tree.h"
  34 #include "rtl.h"
  35 #include "expr.h"
  36 #include "flags.h"
  37 #include "cp-tree.h"
  38 #include "decl.h"
  39 #include "lex.h"
  40 #include <signal.h>
  41 #include "defaults.h"
  42 #include "output.h"
  43 #include "except.h"
  44 #include "toplev.h"
  45 #include "../hash.h"
  46 #include "defaults.h"
  47 #include "ggc.h"
  48
  49 extern int current_class_depth;
  50
  51 extern tree static_ctors, static_dtors;
  52
  53 extern tree global_namespace;
  54
  55 extern int (*valid_lang_attribute) PARAMS ((tree, tree, tree, tree));
  56
  57 /* Use garbage collection.  */
  58
  59 int ggc_p = 1;
  60
  61 #ifndef WCHAR_UNSIGNED
  62 #define WCHAR_UNSIGNED 0
  63 #endif
  64
  65 #ifndef CHAR_TYPE_SIZE
  66 #define CHAR_TYPE_SIZE BITS_PER_UNIT
  67 #endif
  68
  69 #ifndef BOOL_TYPE_SIZE
  70 #ifdef SLOW_BYTE_ACCESS
  71 /* In the new ABI, `bool' has size and alignment `1', on all
  72    platforms.  */
  73 #define BOOL_TYPE_SIZE \
  74   ((SLOW_BYTE_ACCESS && !flag_new_abi) ? (POINTER_SIZE) : (CHAR_TYPE_SIZE))
  75 #else
  76 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
  77 #endif
  78 #endif
  79
  80 /* We let tm.h override the types used here, to handle trivial differences
  81    such as the choice of unsigned int or long unsigned int for size_t.
  82    When machines start needing nontrivial differences in the size type,
  83    it would be best to do something here to figure out automatically
  84    from other information what type to use.  */
  85
  86 #ifndef SIZE_TYPE
  87 #define SIZE_TYPE "long unsigned int"
  88 #endif
  89
  90 #ifndef PTRDIFF_TYPE
  91 #define PTRDIFF_TYPE "long int"
  92 #endif
  93
  94 #ifndef WCHAR_TYPE
  95 #define WCHAR_TYPE "int"
  96 #endif
  97
  98 static tree grokparms                           PARAMS ((tree, int));
  99 static const char *redeclaration_error_message  PARAMS ((tree, tree));
 100
 101 static void push_binding_level PARAMS ((struct binding_level *, int,
 102                                       int));
 103 static void pop_binding_level PARAMS ((void));
 104 static void suspend_binding_level PARAMS ((void));
 105 static void resume_binding_level PARAMS ((struct binding_level *));
 106 static struct binding_level *make_binding_level PARAMS ((void));
 107 static void declare_namespace_level PARAMS ((void));
 108 static void signal_catch PARAMS ((int)) ATTRIBUTE_NORETURN;
 109 static int decl_jump_unsafe PARAMS ((tree));
 110 static void storedecls PARAMS ((tree));
 111 static void require_complete_types_for_parms PARAMS ((tree));
 112 static int ambi_op_p PARAMS ((enum tree_code));
 113 static int unary_op_p PARAMS ((enum tree_code));
 114 static tree store_bindings PARAMS ((tree, tree));
 115 static tree lookup_tag_reverse PARAMS ((tree, tree));
 116 static tree obscure_complex_init PARAMS ((tree, tree));
 117 static tree lookup_name_real PARAMS ((tree, int, int, int));
 118 static void warn_extern_redeclared_static PARAMS ((tree, tree));
 119 static void grok_reference_init PARAMS ((tree, tree, tree));
 120 static tree grokfndecl PARAMS ((tree, tree, tree, tree, int,
 121                               enum overload_flags, tree,
 122                               tree, int, int, int, int, int, int, tree));
 123 static tree grokvardecl PARAMS ((tree, tree, RID_BIT_TYPE *, int, int, tree));
 124 static tree lookup_tag PARAMS ((enum tree_code, tree,
 125                               struct binding_level *, int));
 126 static void set_identifier_type_value_with_scope
 127         PARAMS ((tree, tree, struct binding_level *));
 128 static void record_builtin_type PARAMS ((enum rid, const char *, tree));
 129 static void record_unknown_type PARAMS ((tree, const char *));
 130 static tree build_library_fn_1 PARAMS ((tree, enum tree_code, tree));
 131 static int member_function_or_else PARAMS ((tree, tree, enum overload_flags));
 132 static void bad_specifiers PARAMS ((tree, const char *, int, int, int, int,
 133                                   int));
 134 static void lang_print_error_function PARAMS ((const char *));
 135 static tree maybe_process_template_type_declaration PARAMS ((tree, int, struct binding_level*));
 136 static void check_for_uninitialized_const_var PARAMS ((tree));
 137 static unsigned long typename_hash PARAMS ((hash_table_key));
 138 static boolean typename_compare PARAMS ((hash_table_key, hash_table_key));
 139 static void push_binding PARAMS ((tree, tree, struct binding_level*));
 140 static int add_binding PARAMS ((tree, tree));
 141 static void pop_binding PARAMS ((tree, tree));
 142 static tree local_variable_p_walkfn PARAMS ((tree *, int *, void *));
 143 static tree find_binding PARAMS ((tree, tree));
 144 static tree select_decl PARAMS ((tree, int));
 145 static int lookup_flags PARAMS ((int, int));
 146 static tree qualify_lookup PARAMS ((tree, int));
 147 static tree record_builtin_java_type PARAMS ((const char *, int));
 148 static const char *tag_name PARAMS ((enum tag_types code));
 149 static void find_class_binding_level PARAMS ((void));
 150 static struct binding_level *innermost_nonclass_level PARAMS ((void));
 151 static void warn_about_implicit_typename_lookup PARAMS ((tree, tree));
 152 static int walk_namespaces_r PARAMS ((tree, walk_namespaces_fn, void *));
 153 static int walk_globals_r PARAMS ((tree, void *));
 154 static void add_decl_to_level PARAMS ((tree, struct binding_level *));
 155 static tree make_label_decl PARAMS ((tree, int));
 156 static void use_label PARAMS ((tree));
 157 static void check_previous_goto_1 PARAMS ((tree, struct binding_level *, tree,
 158                                            const char *, int));
 159 static void check_previous_goto PARAMS ((struct named_label_use_list *));
 160 static void check_switch_goto PARAMS ((struct binding_level *));
 161 static void check_previous_gotos PARAMS ((tree));
 162 static void pop_label PARAMS ((tree, tree));
 163 static void pop_labels PARAMS ((tree));
 164 static void maybe_deduce_size_from_array_init PARAMS ((tree, tree));
 165 static void layout_var_decl PARAMS ((tree));
 166 static void maybe_commonize_var PARAMS ((tree));
 167 static tree check_initializer PARAMS ((tree, tree));
 168 static void make_rtl_for_nonlocal_decl PARAMS ((tree, tree, const char *));
 169 static void push_cp_function_context PARAMS ((struct function *));
 170 static void pop_cp_function_context PARAMS ((struct function *));
 171 static void mark_binding_level PARAMS ((void *));
 172 static void mark_named_label_lists PARAMS ((void *, void *));
 173 static void mark_cp_function_context PARAMS ((struct function *));
 174 static void mark_saved_scope PARAMS ((void *));
 175 static void mark_lang_function PARAMS ((struct language_function *));
 176 static void mark_stmt_tree PARAMS ((struct stmt_tree *));
 177 static void save_function_data PARAMS ((tree));
 178 static void check_function_type PARAMS ((tree));
 179 static void destroy_local_var PARAMS ((tree));
 180 static void finish_constructor_body PARAMS ((void));
 181 static void finish_destructor_body PARAMS ((void));
 182 static tree create_array_type_for_decl PARAMS ((tree, tree, tree));
 183 static tree get_atexit_node PARAMS ((void));
 184 static tree get_dso_handle_node PARAMS ((void));
 185 static tree start_cleanup_fn PARAMS ((void));
 186 static void end_cleanup_fn PARAMS ((void));
 187 static tree cp_make_fname_decl PARAMS ((tree, const char *, int));
 188 static void initialize_predefined_identifiers PARAMS ((void));
 189 static tree check_special_function_return_type
 190   PARAMS ((special_function_kind, tree, tree, tree));
 191 static tree push_cp_library_fn PARAMS ((enum tree_code, tree));
 192 static tree build_cp_library_fn PARAMS ((tree, enum tree_code, tree));
 193
 194 #if defined (DEBUG_CP_BINDING_LEVELS)
 195 static void indent PARAMS ((void));
 196 #endif
 197
 198 /* Erroneous argument lists can use this *IFF* they do not modify it.  */
 199 tree error_mark_list;
 200
 201 /* The following symbols are subsumed in the cp_global_trees array, and
 202    listed here individually for documentation purposes.
 203
 204    C++ extensions
 205         tree wchar_decl_node;
 206         tree void_zero_node;
 207
 208         tree vtable_entry_type;
 209         tree delta_type_node;
 210 #if 0
 211    Old rtti stuff.
 212         tree __baselist_desc_type_node;
 213         tree __i_desc_type_node, __m_desc_type_node;
 214         tree __t_desc_array_type, __i_desc_array_type, __m_desc_array_type;
 215 #endif
 216         tree __t_desc_type_node;
 217 #if 0
 218         tree __tp_desc_type_node;
 219 #endif
 220         tree ti_desc_type_node;
 221         tree bltn_desc_type_node, ptr_desc_type_node;
 222         tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
 223         tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
 224         tree ptm_desc_type_node;
 225         tree base_desc_type_node;
 226 #if 0
 227    Not needed yet?  May be needed one day?
 228         tree __bltn_desc_array_type, __user_desc_array_type, __class_desc_array_type;
 229         tree __ptr_desc_array_type, __attr_dec_array_type, __func_desc_array_type;
 230         tree __ptmf_desc_array_type, __ptmd_desc_array_type;
 231 #endif
 232
 233         tree class_type_node, record_type_node, union_type_node, enum_type_node;
 234         tree unknown_type_node;
 235
 236    Array type `vtable_entry_type[]'
 237
 238         tree vtbl_type_node;
 239         tree vtbl_ptr_type_node;
 240
 241    Namespaces,
 242
 243         tree std_node;
 244         tree abi_node;
 245
 246    A FUNCTION_DECL which can call `abort'.  Not necessarily the
 247    one that the user will declare, but sufficient to be called
 248    by routines that want to abort the program.
 249
 250         tree abort_fndecl;
 251
 252    The FUNCTION_DECL for the default `::operator delete'.
 253
 254         tree global_delete_fndecl;
 255
 256    Used by RTTI
 257         tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
 258         tree tinfo_var_id;
 259
 260 */
 261
 262 tree cp_global_trees[CPTI_MAX];
 263
 264 /* Indicates that there is a type value in some namespace, although
 265    that is not necessarily in scope at the moment.  */
 266
 267 static tree global_type_node;
 268
 269 /* Namespace std.  */
 270 int in_std;
 271
 272 /* Expect only namespace names now. */
 273 static int only_namespace_names;
 274
 275 /* If original DECL_RESULT of current function was a register,
 276    but due to being an addressable named return value, would up
 277    on the stack, this variable holds the named return value's
 278    original location.  */
 279
 280 #define original_result_rtx cp_function_chain->x_result_rtx
 281
 282 /* Used only for jumps to as-yet undefined labels, since jumps to
 283    defined labels can have their validity checked immediately.  */
 284
 285 struct named_label_use_list
 286 {
 287   struct binding_level *binding_level;
 288   tree names_in_scope;
 289   tree label_decl;
 290   const char *filename_o_goto;
 291   int lineno_o_goto;
 292   struct named_label_use_list *next;
 293 };
 294
 295 #define named_label_uses cp_function_chain->x_named_label_uses
 296
 297 /* A list of objects which have constructors or destructors
 298    which reside in the global scope.  The decl is stored in
 299    the TREE_VALUE slot and the initializer is stored
 300    in the TREE_PURPOSE slot.  */
 301 tree static_aggregates;
 302
 303 /* -- end of C++ */
 304
 305 /* A node for the integer constants 2, and 3.  */
 306
 307 tree integer_two_node, integer_three_node;
 308
 309 /* Parsing a function declarator leaves here a chain of structure
 310    and enum types declared in the parmlist.  */
 311
 312 static tree last_function_parm_tags;
 313
 314 /* Similar, for last_function_parm_tags.  */
 315 tree last_function_parms;
 316 static tree current_function_parm_tags;
 317
 318 /* A list of all LABEL_DECLs in the function that have names.  Here so
 319    we can clear out their names' definitions at the end of the
 320    function, and so we can check the validity of jumps to these labels.  */
 321
 322 struct named_label_list
 323 {
 324   struct binding_level *binding_level;
 325   tree names_in_scope;
 326   tree old_value;
 327   tree label_decl;
 328   tree bad_decls;
 329   int eh_region;
 330   struct named_label_list *next;
 331 };
 332
 333 #define named_labels cp_function_chain->x_named_labels
 334
 335 /* Set to 0 at beginning of a function definition, and whenever
 336    a label (case or named) is defined.  Set to value of expression
 337    returned from function when that value can be transformed into
 338    a named return value.  */
 339
 340 tree current_function_return_value;
 341
 342 /* Nonzero means use the ISO C99 dialect of C.  */
 343
 344 int flag_isoc99;
 345
 346 /* Nonzero means give `double' the same size as `float'.  */
 347
 348 extern int flag_short_double;
 349
 350 /* Nonzero means don't recognize any builtin functions.  */
 351
 352 extern int flag_no_builtin;
 353
 354 /* Nonzero means don't recognize the non-ANSI builtin functions.
 355    -ansi sets this.  */
 356
 357 extern int flag_no_nonansi_builtin;
 358
 359 /* Nonzero if we want to conserve space in the .o files.  We do this
 360    by putting uninitialized data and runtime initialized data into
 361    .common instead of .data at the expense of not flagging multiple
 362    definitions.  */
 363 extern int flag_conserve_space;
 364 \f
 365 /* C and C++ flags are in decl2.c.  */
 366
 367 /* Flag used when debugging spew.c */
 368
 369 extern int spew_debug;
 370
 371 /* A expression of value 0 with the same precision as a sizetype
 372    node, but signed.  */
 373 tree signed_size_zero_node;
 374
 375 /* The name of the anonymous namespace, throughout this translation
 376    unit.  */
 377 tree anonymous_namespace_name;
 378
 379 \f
 380 /* For each binding contour we allocate a binding_level structure
 381    which records the names defined in that contour.
 382    Contours include:
 383     0) the global one
 384     1) one for each function definition,
 385        where internal declarations of the parameters appear.
 386     2) one for each compound statement,
 387        to record its declarations.
 388
 389    The current meaning of a name can be found by searching the levels
 390    from the current one out to the global one.
 391
 392    Off to the side, may be the class_binding_level.  This exists only
 393    to catch class-local declarations.  It is otherwise nonexistent.
 394
 395    Also there may be binding levels that catch cleanups that must be
 396    run when exceptions occur.  Thus, to see whether a name is bound in
 397    the current scope, it is not enough to look in the
 398    CURRENT_BINDING_LEVEL.  You should use lookup_name_current_level
 399    instead.  */
 400
 401 /* Note that the information in the `names' component of the global contour
 402    is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers.  */
 403
 404 struct binding_level
 405   {
 406     /* A chain of _DECL nodes for all variables, constants, functions,
 407        and typedef types.  These are in the reverse of the order
 408        supplied.  There may be OVERLOADs on this list, too, but they
 409        are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD.  */
 410     tree names;
 411
 412     /* A list of structure, union and enum definitions, for looking up
 413        tag names.
 414        It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
 415        or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
 416        or ENUMERAL_TYPE node.
 417
 418        C++: the TREE_VALUE nodes can be simple types for
 419        component_bindings.  */
 420     tree tags;
 421
 422     /* A list of USING_DECL nodes. */
 423     tree usings;
 424
 425     /* A list of used namespaces. PURPOSE is the namespace,
 426        VALUE the common ancestor with this binding_level's namespace. */
 427     tree using_directives;
 428
 429     /* If this binding level is the binding level for a class, then
 430        class_shadowed is a TREE_LIST.  The TREE_PURPOSE of each node
 431        is the name of an entity bound in the class; the TREE_VALUE is
 432        the IDENTIFIER_CLASS_VALUE before we entered the class.  Thus,
 433        when leaving class scope, we can restore the
 434        IDENTIFIER_CLASS_VALUE by walking this list.  The TREE_TYPE is
 435        the DECL bound by this name in the class.  */
 436     tree class_shadowed;
 437
 438     /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
 439        is used for all binding levels.  */
 440     tree type_shadowed;
 441
 442     /* A TREE_LIST.  Each TREE_VALUE is the LABEL_DECL for a local
 443        label in this scope.  The TREE_PURPOSE is the previous value of
 444        the IDENTIFIER_LABEL VALUE.  */
 445     tree shadowed_labels;
 446
 447     /* For each level (except not the global one),
 448        a chain of BLOCK nodes for all the levels
 449        that were entered and exited one level down.  */
 450     tree blocks;
 451
 452     /* The BLOCK node for this level, if one has been preallocated.
 453        If 0, the BLOCK is allocated (if needed) when the level is popped.  */
 454     tree this_block;
 455
 456     /* The _TYPE node for this level, if parm_flag == 2.  */
 457     tree this_class;
 458
 459     /* The binding level which this one is contained in (inherits from).  */
 460     struct binding_level *level_chain;
 461
 462     /* List of decls in `names' that have incomplete
 463        structure or union types.  */
 464     tree incomplete;
 465
 466     /* List of VAR_DECLS saved from a previous for statement.
 467        These would be dead in ISO-conforming code, but might
 468        be referenced in ARM-era code.  These are stored in a
 469        TREE_LIST; the TREE_VALUE is the actual declaration.  */
 470     tree dead_vars_from_for;
 471
 472     /* 1 for the level that holds the parameters of a function.
 473        2 for the level that holds a class declaration.  */
 474     unsigned parm_flag : 2;
 475
 476     /* 1 means make a BLOCK for this level regardless of all else.
 477        2 for temporary binding contours created by the compiler.  */
 478     unsigned keep : 2;
 479
 480     /* Nonzero if this level "doesn't exist" for tags.  */
 481     unsigned tag_transparent : 1;
 482
 483     /* Nonzero if this level can safely have additional
 484        cleanup-needing variables added to it.  */
 485     unsigned more_cleanups_ok : 1;
 486     unsigned have_cleanups : 1;
 487
 488     /* Nonzero if this scope is for storing the decls for template
 489        parameters and generic decls; these decls will be discarded and
 490        replaced with a TEMPLATE_DECL.  */
 491     unsigned template_parms_p : 1;
 492
 493     /* Nonzero if this scope corresponds to the `<>' in a
 494        `template <>' clause.  Whenever this flag is set,
 495        TEMPLATE_PARMS_P will be set as well.  */
 496     unsigned template_spec_p : 1;
 497
 498     /* This is set for a namespace binding level.  */
 499     unsigned namespace_p : 1;
 500
 501     /* True if this level is that of a for-statement where we need to
 502        worry about ambiguous (ARM or ISO) scope rules.  */
 503     unsigned is_for_scope : 1;
 504
 505     /* True if this level corresponds to an EH region, as for a try block.
 506        Currently this information is only available while building the
 507        tree structure.  */
 508     unsigned eh_region : 1;
 509
 510     /* Four bits left for this word.  */
 511
 512 #if defined(DEBUG_CP_BINDING_LEVELS)
 513     /* Binding depth at which this level began.  */
 514     unsigned binding_depth;
 515 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 516   };
 517
 518 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
 519
 520 /* The binding level currently in effect.  */
 521
 522 #define current_binding_level                   \
 523   (cfun                                         \
 524    ? cp_function_chain->bindings                \
 525    : scope_chain->bindings)
 526
 527 /* The binding level of the current class, if any.  */
 528
 529 #define class_binding_level scope_chain->class_bindings
 530
 531 /* A chain of binding_level structures awaiting reuse.  */
 532
 533 static struct binding_level *free_binding_level;
 534
 535 /* The outermost binding level, for names of file scope.
 536    This is created when the compiler is started and exists
 537    through the entire run.  */
 538
 539 static struct binding_level *global_binding_level;
 540
 541 /* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
 542
 543 static int keep_next_level_flag;
 544
 545 #if defined(DEBUG_CP_BINDING_LEVELS)
 546 static int binding_depth = 0;
 547 static int is_class_level = 0;
 548
 549 static void
 550 indent ()
 551 {
 552   register unsigned i;
 553
 554   for (i = 0; i < binding_depth*2; i++)
 555     putc (' ', stderr);
 556 }
 557 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 558
 559 static tree pushdecl_with_scope PARAMS ((tree, struct binding_level *));
 560
 561 static void
 562 push_binding_level (newlevel, tag_transparent, keep)
 563      struct binding_level *newlevel;
 564      int tag_transparent, keep;
 565 {
 566   /* Add this level to the front of the chain (stack) of levels that
 567      are active.  */
 568   bzero ((char*) newlevel, sizeof (struct binding_level));
 569   newlevel->level_chain = current_binding_level;
 570   current_binding_level = newlevel;
 571   newlevel->tag_transparent = tag_transparent;
 572   newlevel->more_cleanups_ok = 1;
 573
 574   newlevel->keep = keep;
 575 #if defined(DEBUG_CP_BINDING_LEVELS)
 576   newlevel->binding_depth = binding_depth;
 577   indent ();
 578   fprintf (stderr, "push %s level 0x%08x line %d\n",
 579            (is_class_level) ? "class" : "block", newlevel, lineno);
 580   is_class_level = 0;
 581   binding_depth++;
 582 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 583 }
 584
 585 /* Find the innermost enclosing class scope, and reset
 586    CLASS_BINDING_LEVEL appropriately.  */
 587
 588 static void
 589 find_class_binding_level ()
 590 {
 591   struct binding_level *level = current_binding_level;
 592
 593   while (level && level->parm_flag != 2)
 594     level = level->level_chain;
 595   if (level && level->parm_flag == 2)
 596     class_binding_level = level;
 597   else
 598     class_binding_level = 0;
 599 }
 600
 601 static void
 602 pop_binding_level ()
 603 {
 604   if (global_binding_level)
 605     {
 606       /* Cannot pop a level, if there are none left to pop.  */
 607       if (current_binding_level == global_binding_level)
 608         my_friendly_abort (123);
 609     }
 610   /* Pop the current level, and free the structure for reuse.  */
 611 #if defined(DEBUG_CP_BINDING_LEVELS)
 612   binding_depth--;
 613   indent ();
 614   fprintf (stderr, "pop  %s level 0x%08x line %d\n",
 615           (is_class_level) ? "class" : "block",
 616           current_binding_level, lineno);
 617   if (is_class_level != (current_binding_level == class_binding_level))
 618     {
 619       indent ();
 620       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 621     }
 622   is_class_level = 0;
 623 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 624   {
 625     register struct binding_level *level = current_binding_level;
 626     current_binding_level = current_binding_level->level_chain;
 627     level->level_chain = free_binding_level;
 628 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
 629     if (level->binding_depth != binding_depth)
 630       abort ();
 631 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 632     free_binding_level = level;
 633     find_class_binding_level ();
 634   }
 635 }
 636
 637 static void
 638 suspend_binding_level ()
 639 {
 640   if (class_binding_level)
 641     current_binding_level = class_binding_level;
 642
 643   if (global_binding_level)
 644     {
 645       /* Cannot suspend a level, if there are none left to suspend.  */
 646       if (current_binding_level == global_binding_level)
 647         my_friendly_abort (123);
 648     }
 649   /* Suspend the current level.  */
 650 #if defined(DEBUG_CP_BINDING_LEVELS)
 651   binding_depth--;
 652   indent ();
 653   fprintf (stderr, "suspend  %s level 0x%08x line %d\n",
 654           (is_class_level) ? "class" : "block",
 655           current_binding_level, lineno);
 656   if (is_class_level != (current_binding_level == class_binding_level))
 657     {
 658       indent ();
 659       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 660     }
 661   is_class_level = 0;
 662 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 663   current_binding_level = current_binding_level->level_chain;
 664   find_class_binding_level ();
 665 }
 666
 667 static void
 668 resume_binding_level (b)
 669      struct binding_level *b;
 670 {
 671   /* Resuming binding levels is meant only for namespaces,
 672      and those cannot nest into classes. */
 673   my_friendly_assert(!class_binding_level, 386);
 674   /* Also, resuming a non-directly nested namespace is a no-no.  */
 675   my_friendly_assert(b->level_chain == current_binding_level, 386);
 676   current_binding_level = b;
 677 #if defined(DEBUG_CP_BINDING_LEVELS)
 678   b->binding_depth = binding_depth;
 679   indent ();
 680   fprintf (stderr, "resume %s level 0x%08x line %d\n",
 681            (is_class_level) ? "class" : "block", b, lineno);
 682   is_class_level = 0;
 683   binding_depth++;
 684 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 685 }
 686 \f
 687 /* Create a new `struct binding_level'.  */
 688
 689 static
 690 struct binding_level *
 691 make_binding_level ()
 692 {
 693   /* NOSTRICT */
 694   return (struct binding_level *) xmalloc (sizeof (struct binding_level));
 695 }
 696
 697 /* Nonzero if we are currently in the global binding level.  */
 698
 699 int
 700 global_bindings_p ()
 701 {
 702   return current_binding_level == global_binding_level;
 703 }
 704
 705 /* Return the innermost binding level that is not for a class scope.  */
 706
 707 static struct binding_level *
 708 innermost_nonclass_level ()
 709 {
 710   struct binding_level *b;
 711
 712   b = current_binding_level;
 713   while (b->parm_flag == 2)
 714     b = b->level_chain;
 715
 716   return b;
 717 }
 718
 719 /* Nonzero if we are currently in a toplevel binding level.  This
 720    means either the global binding level or a namespace in a toplevel
 721    binding level.  Since there are no non-toplevel namespace levels,
 722    this really means any namespace or template parameter level.  We
 723    also include a class whose context is toplevel.  */
 724
 725 int
 726 toplevel_bindings_p ()
 727 {
 728   struct binding_level *b = innermost_nonclass_level ();
 729
 730   return b->namespace_p || b->template_parms_p;
 731 }
 732
 733 /* Nonzero if this is a namespace scope, or if we are defining a class
 734    which is itself at namespace scope, or whose enclosing class is
 735    such a class, etc.  */
 736
 737 int
 738 namespace_bindings_p ()
 739 {
 740   struct binding_level *b = innermost_nonclass_level ();
 741
 742   return b->namespace_p;
 743 }
 744
 745 /* If KEEP is non-zero, make a BLOCK node for the next binding level,
 746    unconditionally.  Otherwise, use the normal logic to decide whether
 747    or not to create a BLOCK.  */
 748
 749 void
 750 keep_next_level (keep)
 751      int keep;
 752 {
 753   keep_next_level_flag = keep;
 754 }
 755
 756 /* Nonzero if the current level needs to have a BLOCK made.  */
 757
 758 int
 759 kept_level_p ()
 760 {
 761   return (current_binding_level->blocks != NULL_TREE
 762           || current_binding_level->keep
 763           || current_binding_level->names != NULL_TREE
 764           || (current_binding_level->tags != NULL_TREE
 765               && !current_binding_level->tag_transparent));
 766 }
 767
 768 static void
 769 declare_namespace_level ()
 770 {
 771   current_binding_level->namespace_p = 1;
 772 }
 773
 774 /* Returns non-zero if this scope was created to store template
 775    parameters.  */
 776
 777 int
 778 template_parm_scope_p ()
 779 {
 780   return current_binding_level->template_parms_p;
 781 }
 782
 783 /* Returns the kind of template specialization we are currently
 784    processing, given that it's declaration contained N_CLASS_SCOPES
 785    explicit scope qualifications.  */
 786
 787 tmpl_spec_kind
 788 current_tmpl_spec_kind (n_class_scopes)
 789      int n_class_scopes;
 790 {
 791   int n_template_parm_scopes = 0;
 792   int seen_specialization_p = 0;
 793   int innermost_specialization_p = 0;
 794   struct binding_level *b;
 795
 796   /* Scan through the template parameter scopes.  */
 797   for (b = current_binding_level; b->template_parms_p; b = b->level_chain)
 798     {
 799       /* If we see a specialization scope inside a parameter scope,
 800          then something is wrong.  That corresponds to a declaration
 801          like:
 802
 803             template <class T> template <> ...
 804
 805          which is always illegal since [temp.expl.spec] forbids the
 806          specialization of a class member template if the enclosing
 807          class templates are not explicitly specialized as well.  */
 808       if (b->template_spec_p)
 809         {
 810           if (n_template_parm_scopes == 0)
 811             innermost_specialization_p = 1;
 812           else
 813             seen_specialization_p = 1;
 814         }
 815       else if (seen_specialization_p == 1)
 816         return tsk_invalid_member_spec;
 817
 818       ++n_template_parm_scopes;
 819     }
 820
 821   /* Handle explicit instantiations.  */
 822   if (processing_explicit_instantiation)
 823     {
 824       if (n_template_parm_scopes != 0)
 825         /* We've seen a template parameter list during an explicit
 826            instantiation.  For example:
 827
 828              template <class T> template void f(int);
 829
 830            This is erroneous.  */
 831         return tsk_invalid_expl_inst;
 832       else
 833         return tsk_expl_inst;
 834     }
 835
 836   if (n_template_parm_scopes < n_class_scopes)
 837     /* We've not seen enough template headers to match all the
 838        specialized classes present.  For example:
 839
 840          template <class T> void R<T>::S<T>::f(int);
 841
 842        This is illegal; there needs to be one set of template
 843        parameters for each class.  */
 844     return tsk_insufficient_parms;
 845   else if (n_template_parm_scopes == n_class_scopes)
 846     /* We're processing a non-template declaration (even though it may
 847        be a member of a template class.)  For example:
 848
 849          template <class T> void S<T>::f(int);
 850
 851        The `class T' maches the `S<T>', leaving no template headers
 852        corresponding to the `f'.  */
 853     return tsk_none;
 854   else if (n_template_parm_scopes > n_class_scopes + 1)
 855     /* We've got too many template headers.  For example:
 856
 857          template <> template <class T> void f (T);
 858
 859        There need to be more enclosing classes.  */
 860     return tsk_excessive_parms;
 861   else
 862     /* This must be a template.  It's of the form:
 863
 864          template <class T> template <class U> void S<T>::f(U);
 865
 866        This is a specialization if the innermost level was a
 867        specialization; otherwise it's just a definition of the
 868        template.  */
 869     return innermost_specialization_p ? tsk_expl_spec : tsk_template;
 870 }
 871
 872 void
 873 set_class_shadows (shadows)
 874      tree shadows;
 875 {
 876   class_binding_level->class_shadowed = shadows;
 877 }
 878
 879 /* Enter a new binding level.
 880    If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
 881    not for that of tags.  */
 882
 883 void
 884 pushlevel (tag_transparent)
 885      int tag_transparent;
 886 {
 887   struct binding_level *newlevel;
 888
 889   if (cfun && !doing_semantic_analysis_p ())
 890     return;
 891
 892   /* Reuse or create a struct for this binding level.  */
 893 #if defined(DEBUG_CP_BINDING_LEVELS)
 894   if (0)
 895 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
 896   if (free_binding_level)
 897 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
 898     {
 899       newlevel = free_binding_level;
 900       free_binding_level = free_binding_level->level_chain;
 901     }
 902   else
 903     newlevel = make_binding_level ();
 904
 905   push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
 906   GNU_xref_start_scope ((HOST_WIDE_INT) newlevel);
 907   keep_next_level_flag = 0;
 908 }
 909
 910 /* Enter a new scope.  The KIND indicates what kind of scope is being
 911    created.  */
 912
 913 void
 914 begin_scope (sk)
 915      scope_kind sk;
 916 {
 917   pushlevel (0);
 918
 919   switch (sk)
 920     {
 921     case sk_template_spec:
 922       current_binding_level->template_spec_p = 1;
 923       /* Fall through.  */
 924
 925     case sk_template_parms:
 926       current_binding_level->template_parms_p = 1;
 927       break;
 928
 929     default:
 930       my_friendly_abort (20000309);
 931     }
 932 }
 933
 934 /* Exit the current scope.  */
 935
 936 void
 937 finish_scope ()
 938 {
 939   poplevel (0, 0, 0);
 940 }
 941
 942 void
 943 note_level_for_for ()
 944 {
 945   current_binding_level->is_for_scope = 1;
 946 }
 947
 948 /* Record that the current binding level represents a try block.  */
 949
 950 void
 951 note_level_for_eh ()
 952 {
 953   current_binding_level->eh_region = 1;
 954 }
 955
 956 /* For a binding between a name and an entity at a block scope,
 957    this is the `struct binding_level' for the block.  */
 958 #define BINDING_LEVEL(NODE) \
 959    (((struct tree_binding*)NODE)->scope.level)
 960
 961 /* Make DECL the innermost binding for ID.  The LEVEL is the binding
 962    level at which this declaration is being bound.  */
 963
 964 static void
 965 push_binding (id, decl, level)
 966      tree id;
 967      tree decl;
 968      struct binding_level* level;
 969 {
 970   tree binding;
 971
 972   binding = make_node (CPLUS_BINDING);
 973
 974   /* Now, fill in the binding information.  */
 975   BINDING_VALUE (binding) = decl;
 976   BINDING_TYPE (binding) = NULL_TREE;
 977   BINDING_LEVEL (binding) = level;
 978   INHERITED_VALUE_BINDING_P (binding) = 0;
 979   LOCAL_BINDING_P (binding) = (level != class_binding_level);
 980   BINDING_HAS_LEVEL_P (binding) = 1;
 981
 982   /* And put it on the front of the list of bindings for ID.  */
 983   TREE_CHAIN (binding) = IDENTIFIER_BINDING (id);
 984   IDENTIFIER_BINDING (id) = binding;
 985 }
 986
 987 /* ID is already bound in the current scope.  But, DECL is an
 988    additional binding for ID in the same scope.  This is the `struct
 989    stat' hack whereby a non-typedef class-name or enum-name can be
 990    bound at the same level as some other kind of entity.  It's the
 991    responsibility of the caller to check that inserting this name is
 992    legal here.  Returns nonzero if the new binding was successful.  */
 993 static int
 994 add_binding (id, decl)
 995      tree id;
 996      tree decl;
 997 {
 998   tree binding = IDENTIFIER_BINDING (id);
 999   int ok = 1;
1000
1001   if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
1002     /* The new name is the type name.  */
1003     BINDING_TYPE (binding) = decl;
1004   else if (!BINDING_VALUE (binding))
1005     /* This situation arises when push_class_level_binding moves an
1006        inherited type-binding out of the way to make room for a new
1007        value binding.  */
1008     BINDING_VALUE (binding) = decl;
1009   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
1010            && DECL_ARTIFICIAL (BINDING_VALUE (binding)))
1011     {
1012       /* The old binding was a type name.  It was placed in
1013          BINDING_VALUE because it was thought, at the point it was
1014          declared, to be the only entity with such a name.  Move the
1015          type name into the type slot; it is now hidden by the new
1016          binding.  */
1017       BINDING_TYPE (binding) = BINDING_VALUE (binding);
1018       BINDING_VALUE (binding) = decl;
1019       INHERITED_VALUE_BINDING_P (binding) = 0;
1020     }
1021   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
1022            && TREE_CODE (decl) == TYPE_DECL
1023            && DECL_NAME (decl) == DECL_NAME (BINDING_VALUE (binding))
1024            && same_type_p (TREE_TYPE (decl),
1025                            TREE_TYPE (BINDING_VALUE (binding))))
1026     /* We have two typedef-names, both naming the same type to have
1027        the same name.  This is OK because of:
1028
1029          [dcl.typedef]
1030
1031          In a given scope, a typedef specifier can be used to redefine
1032          the name of any type declared in that scope to refer to the
1033          type to which it already refers.  */
1034     ok = 0;
1035   /* There can be two block-scope declarations of the same variable,
1036      so long as they are `extern' declarations.  */
1037   else if (TREE_CODE (decl) == VAR_DECL
1038            && TREE_CODE (BINDING_VALUE (binding)) == VAR_DECL
1039            && DECL_EXTERNAL (decl)
1040            && DECL_EXTERNAL (BINDING_VALUE (binding)))
1041     {
1042       duplicate_decls (decl, BINDING_VALUE (binding));
1043       ok = 0;
1044     }
1045   else
1046     {
1047       cp_error ("declaration of `%#D'", decl);
1048       cp_error_at ("conflicts with previous declaration `%#D'",
1049                    BINDING_VALUE (binding));
1050       ok = 0;
1051     }
1052
1053   return ok;
1054 }
1055
1056 /* Add DECL to the list of things declared in B.  */
1057
1058 static void
1059 add_decl_to_level (decl, b)
1060      tree decl;
1061      struct binding_level *b;
1062 {
1063   /* We build up the list in reverse order, and reverse it later if
1064      necessary.  */
1065   TREE_CHAIN (decl) = b->names;
1066   b->names = decl;
1067 }
1068
1069 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1070    binding level.  If PUSH_USING is set in FLAGS, we know that DECL
1071    doesn't really belong to this binding level, that it got here
1072    through a using-declaration.  */
1073
1074 void
1075 push_local_binding (id, decl, flags)
1076      tree id;
1077      tree decl;
1078      int flags;
1079 {
1080   struct binding_level *b;
1081
1082   /* Skip over any local classes.  This makes sense if we call
1083      push_local_binding with a friend decl of a local class.  */
1084   b = current_binding_level;
1085   while (b->parm_flag == 2)
1086     b = b->level_chain;
1087
1088   if (lookup_name_current_level (id))
1089     {
1090       /* Supplement the existing binding.  */
1091       if (!add_binding (id, decl))
1092         /* It didn't work.  Something else must be bound at this
1093            level.  Do not add DECL to the list of things to pop
1094            later.  */
1095         return;
1096     }
1097   else
1098     /* Create a new binding.  */
1099     push_binding (id, decl, b);
1100
1101   if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1102     /* We must put the OVERLOAD into a TREE_LIST since the
1103        TREE_CHAIN of an OVERLOAD is already used.  Similarly for
1104        decls that got here through a using-declaration.  */
1105     decl = build_tree_list (NULL_TREE, decl);
1106
1107   /* And put DECL on the list of things declared by the current
1108      binding level.  */
1109   add_decl_to_level (decl, b);
1110 }
1111
1112 /* Bind DECL to ID in the class_binding_level.  Returns nonzero if the
1113    binding was successful.  */
1114
1115 int
1116 push_class_binding (id, decl)
1117      tree id;
1118      tree decl;
1119 {
1120   int result = 1;
1121   tree binding = IDENTIFIER_BINDING (id);
1122   tree context;
1123
1124   /* Note that we declared this value so that we can issue an error if
1125      this an illegal redeclaration of a name already used for some
1126      other purpose.  */
1127   note_name_declared_in_class (id, decl);
1128
1129   if (binding && BINDING_LEVEL (binding) == class_binding_level)
1130     /* Supplement the existing binding.  */
1131     result = add_binding (id, decl);
1132   else
1133     /* Create a new binding.  */
1134     push_binding (id, decl, class_binding_level);
1135
1136   /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1137      class-level declaration.  Note that we do not use DECL here
1138      because of the possibility of the `struct stat' hack; if DECL is
1139      a class-name or enum-name we might prefer a field-name, or some
1140      such.  */
1141   IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
1142
1143   /* If this is a binding from a base class, mark it as such.  */
1144   binding = IDENTIFIER_BINDING (id);
1145   if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
1146     {
1147       /* Any implicit typename must be from a base-class.  The
1148          context for an implicit typename declaration is always
1149          the derived class in which the lookup was done, so the checks
1150          based on the context of DECL below will not trigger.  */
1151       if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl))
1152         INHERITED_VALUE_BINDING_P (binding) = 1;
1153       else
1154         {
1155           if (TREE_CODE (decl) == OVERLOAD)
1156             context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
1157           else
1158             {
1159               my_friendly_assert (DECL_P (decl), 0);
1160               context = CP_DECL_CONTEXT (decl);
1161             }
1162
1163           if (is_properly_derived_from (current_class_type, context))
1164             INHERITED_VALUE_BINDING_P (binding) = 1;
1165           else
1166             INHERITED_VALUE_BINDING_P (binding) = 0;
1167         }
1168     }
1169   else if (BINDING_VALUE (binding) == decl)
1170     /* We only encounter a TREE_LIST when push_class_decls detects an
1171        ambiguity.  Such an ambiguity can be overridden by a definition
1172        in this class.  */
1173     INHERITED_VALUE_BINDING_P (binding) = 1;
1174
1175   return result;
1176 }
1177
1178 /* Remove the binding for DECL which should be the innermost binding
1179    for ID.  */
1180
1181 static void
1182 pop_binding (id, decl)
1183      tree id;
1184      tree decl;
1185 {
1186   tree binding;
1187
1188   if (id == NULL_TREE)
1189     /* It's easiest to write the loops that call this function without
1190        checking whether or not the entities involved have names.  We
1191        get here for such an entity.  */
1192     return;
1193
1194   /* Get the innermost binding for ID.  */
1195   binding = IDENTIFIER_BINDING (id);
1196
1197   /* The name should be bound.  */
1198   my_friendly_assert (binding != NULL_TREE, 0);
1199
1200   /* The DECL will be either the ordinary binding or the type
1201      binding for this identifier.  Remove that binding.  */
1202   if (BINDING_VALUE (binding) == decl)
1203     BINDING_VALUE (binding) = NULL_TREE;
1204   else if (BINDING_TYPE (binding) == decl)
1205     BINDING_TYPE (binding) = NULL_TREE;
1206   else
1207     my_friendly_abort (0);
1208
1209   if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
1210     /* We're completely done with the innermost binding for this
1211        identifier.  Unhook it from the list of bindings.  */
1212     IDENTIFIER_BINDING (id) = TREE_CHAIN (binding);
1213 }
1214
1215 /* When a label goes out of scope, check to see if that label was used
1216    in a valid manner, and issue any appropriate warnings or errors.  */
1217
1218 static void
1219 pop_label (label, old_value)
1220      tree label;
1221      tree old_value;
1222 {
1223   if (!processing_template_decl && doing_semantic_analysis_p ())
1224     {
1225       if (DECL_INITIAL (label) == NULL_TREE)
1226         {
1227           cp_error_at ("label `%D' used but not defined", label);
1228           /* Avoid crashing later.  */
1229           define_label (input_filename, 1, DECL_NAME (label));
1230         }
1231       else if (warn_unused_label && !TREE_USED (label))
1232         cp_warning_at ("label `%D' defined but not used", label);
1233     }
1234
1235   SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
1236 }
1237
1238 /* At the end of a function, all labels declared within the fucntion
1239    go out of scope.  BLOCK is the top-level block for the
1240    function.  */
1241
1242 static void
1243 pop_labels (block)
1244      tree block;
1245 {
1246   struct named_label_list *link;
1247
1248   /* Clear out the definitions of all label names, since their scopes
1249      end here.  */
1250   for (link = named_labels; link; link = link->next)
1251     {
1252       pop_label (link->label_decl, link->old_value);
1253       /* Put the labels into the "variables" of the top-level block,
1254          so debugger can see them.  */
1255       TREE_CHAIN (link->label_decl) = BLOCK_VARS (block);
1256       BLOCK_VARS (block) = link->label_decl;
1257     }
1258
1259   named_labels = NULL;
1260 }
1261
1262 /* Exit a binding level.
1263    Pop the level off, and restore the state of the identifier-decl mappings
1264    that were in effect when this level was entered.
1265
1266    If KEEP == 1, this level had explicit declarations, so
1267    and create a "block" (a BLOCK node) for the level
1268    to record its declarations and subblocks for symbol table output.
1269
1270    If FUNCTIONBODY is nonzero, this level is the body of a function,
1271    so create a block as if KEEP were set and also clear out all
1272    label names.
1273
1274    If REVERSE is nonzero, reverse the order of decls before putting
1275    them into the BLOCK.  */
1276
1277 tree
1278 poplevel (keep, reverse, functionbody)
1279      int keep;
1280      int reverse;
1281      int functionbody;
1282 {
1283   register tree link;
1284   /* The chain of decls was accumulated in reverse order.
1285      Put it into forward order, just for cleanliness.  */
1286   tree decls;
1287   int tmp = functionbody;
1288   int real_functionbody;
1289   tree tags;
1290   tree subblocks;
1291   tree block = NULL_TREE;
1292   tree decl;
1293   int block_previously_created;
1294   int leaving_for_scope;
1295
1296   if (cfun && !doing_semantic_analysis_p ())
1297     return NULL_TREE;
1298
1299   my_friendly_assert (current_binding_level->parm_flag != 2,
1300                       19990916);
1301
1302   real_functionbody = (current_binding_level->keep == 2
1303                        ? ((functionbody = 0), tmp) : functionbody);
1304   tags = functionbody >= 0 ? current_binding_level->tags : 0;
1305   subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1306
1307   my_friendly_assert (!current_binding_level->class_shadowed,
1308                       19990414);
1309
1310   /* We used to use KEEP == 2 to indicate that the new block should go
1311      at the beginning of the list of blocks at this binding level,
1312      rather than the end.  This hack is no longer used.  */
1313   my_friendly_assert (keep == 0 || keep == 1, 0);
1314
1315   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
1316                       (HOST_WIDE_INT) current_binding_level->level_chain,
1317                       current_binding_level->parm_flag,
1318                       current_binding_level->keep);
1319
1320   if (current_binding_level->keep == 1)
1321     keep = 1;
1322
1323   /* Any uses of undefined labels, and any defined labels, now operate
1324      under constraints of next binding contour.  */
1325   if (cfun && !functionbody)
1326     {
1327       struct binding_level *level_chain;
1328       level_chain = current_binding_level->level_chain;
1329       if (level_chain)
1330         {
1331           struct named_label_use_list *uses;
1332           struct named_label_list *labels;
1333           for (labels = named_labels; labels; labels = labels->next)
1334             if (labels->binding_level == current_binding_level)
1335               {
1336                 tree decl;
1337                 if (current_binding_level->eh_region)
1338                   labels->eh_region = 1;
1339                 for (decl = labels->names_in_scope; decl;
1340                      decl = TREE_CHAIN (decl))
1341                   if (decl_jump_unsafe (decl))
1342                     labels->bad_decls = tree_cons (NULL_TREE, decl,
1343                                                    labels->bad_decls);
1344                 labels->binding_level = level_chain;
1345                 labels->names_in_scope = level_chain->names;
1346               }
1347
1348           for (uses = named_label_uses; uses; uses = uses->next)
1349             if (uses->binding_level == current_binding_level)
1350               {
1351                 uses->binding_level = level_chain;
1352                 uses->names_in_scope = level_chain->names;
1353               }
1354         }
1355     }
1356
1357   /* Get the decls in the order they were written.
1358      Usually current_binding_level->names is in reverse order.
1359      But parameter decls were previously put in forward order.  */
1360
1361   if (reverse)
1362     current_binding_level->names
1363       = decls = nreverse (current_binding_level->names);
1364   else
1365     decls = current_binding_level->names;
1366
1367   /* Output any nested inline functions within this block
1368      if they weren't already output.  */
1369   for (decl = decls; decl; decl = TREE_CHAIN (decl))
1370     if (TREE_CODE (decl) == FUNCTION_DECL
1371         && ! TREE_ASM_WRITTEN (decl)
1372         && DECL_INITIAL (decl) != NULL_TREE
1373         && TREE_ADDRESSABLE (decl)
1374         && decl_function_context (decl) == current_function_decl)
1375       {
1376         /* If this decl was copied from a file-scope decl
1377            on account of a block-scope extern decl,
1378            propagate TREE_ADDRESSABLE to the file-scope decl.  */
1379         if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1380           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1381         else
1382           {
1383             push_function_context ();
1384             output_inline_function (decl);
1385             pop_function_context ();
1386           }
1387       }
1388
1389   /* When not in function-at-a-time mode, expand_end_bindings will
1390      warn about unused variables.  But, in function-at-a-time mode
1391      expand_end_bindings is not passed the list of variables in the
1392      current scope, and therefore no warning is emitted.  So, we
1393      explicitly warn here.  */
1394   if (!processing_template_decl)
1395     warn_about_unused_variables (getdecls ());
1396
1397   /* If there were any declarations or structure tags in that level,
1398      or if this level is a function body,
1399      create a BLOCK to record them for the life of this function.  */
1400   block = NULL_TREE;
1401   block_previously_created = (current_binding_level->this_block != NULL_TREE);
1402   if (block_previously_created)
1403     block = current_binding_level->this_block;
1404   else if (keep == 1 || functionbody)
1405     block = make_node (BLOCK);
1406   if (block != NULL_TREE)
1407     {
1408       if (block_previously_created)
1409         {
1410           if (decls || tags || subblocks)
1411             {
1412               if (BLOCK_VARS (block))
1413                 warning ("internal compiler error: debugging info corrupted");
1414
1415               BLOCK_VARS (block) = decls;
1416
1417               /* We can have previous subblocks and new subblocks when
1418                  doing fixup_gotos with complex cleanups.  We chain the new
1419                  subblocks onto the end of any pre-existing subblocks.  */
1420               BLOCK_SUBBLOCKS (block) = chainon (BLOCK_SUBBLOCKS (block),
1421                                                  subblocks);
1422             }
1423         }
1424       else
1425         {
1426           BLOCK_VARS (block) = decls;
1427           BLOCK_SUBBLOCKS (block) = subblocks;
1428         }
1429     }
1430
1431   /* In each subblock, record that this is its superior.  */
1432   if (keep >= 0)
1433     for (link = subblocks; link; link = TREE_CHAIN (link))
1434       BLOCK_SUPERCONTEXT (link) = block;
1435
1436   /* We still support the old for-scope rules, whereby the variables
1437      in a for-init statement were in scope after the for-statement
1438      ended.  We only use the new rules in flag_new_for_scope is
1439      nonzero.  */
1440   leaving_for_scope
1441     = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1442
1443   /* Remove declarations for all the DECLs in this level.  */
1444   for (link = decls; link; link = TREE_CHAIN (link))
1445     {
1446       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL)
1447         {
1448           tree outer_binding
1449             = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1450           tree ns_binding;
1451
1452           if (!outer_binding)
1453             ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1454           else
1455             ns_binding = NULL_TREE;
1456
1457           if (outer_binding
1458               && (BINDING_LEVEL (outer_binding)
1459                   == current_binding_level->level_chain))
1460             /* We have something like:
1461
1462                  int i;
1463                  for (int i; ;);
1464
1465                and we are leaving the `for' scope.  There's no reason to
1466                keep the binding of the inner `i' in this case.  */
1467             pop_binding (DECL_NAME (link), link);
1468           else if ((outer_binding
1469                     && (TREE_CODE (BINDING_VALUE (outer_binding))
1470                         == TYPE_DECL))
1471                    || (ns_binding
1472                        && TREE_CODE (ns_binding) == TYPE_DECL))
1473             /* Here, we have something like:
1474
1475                  typedef int I;
1476
1477                  void f () {
1478                    for (int I; ;);
1479                  }
1480
1481                We must pop the for-scope binding so we know what's a
1482                type and what isn't.  */
1483             pop_binding (DECL_NAME (link), link);
1484           else
1485             {
1486               /* Mark this VAR_DECL as dead so that we can tell we left it
1487                  there only for backward compatibility.  */
1488               DECL_DEAD_FOR_LOCAL (link) = 1;
1489
1490               /* Keep track of what should of have happenned when we
1491                  popped the binding.  */
1492               if (outer_binding && BINDING_VALUE (outer_binding))
1493                 DECL_SHADOWED_FOR_VAR (link)
1494                   = BINDING_VALUE (outer_binding);
1495
1496               /* Add it to the list of dead variables in the next
1497                  outermost binding to that we can remove these when we
1498                  leave that binding.  */
1499               current_binding_level->level_chain->dead_vars_from_for
1500                 = tree_cons (NULL_TREE, link,
1501                              current_binding_level->level_chain->
1502                              dead_vars_from_for);
1503
1504               /* Although we don't pop the CPLUS_BINDING, we do clear
1505                  its BINDING_LEVEL since the level is going away now.  */
1506               BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1507                 = 0;
1508             }
1509         }
1510       else
1511         {
1512           /* Remove the binding.  */
1513           decl = link;
1514           if (TREE_CODE (decl) == TREE_LIST)
1515             decl = TREE_VALUE (decl);
1516           if (DECL_P (decl))
1517             pop_binding (DECL_NAME (decl), decl);
1518           else if (TREE_CODE (decl) == OVERLOAD)
1519             pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1520           else
1521             my_friendly_abort (0);
1522         }
1523     }
1524
1525   /* Remove declarations for any `for' variables from inner scopes
1526      that we kept around.  */
1527   for (link = current_binding_level->dead_vars_from_for;
1528        link; link = TREE_CHAIN (link))
1529     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1530
1531   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
1532   for (link = current_binding_level->type_shadowed;
1533        link; link = TREE_CHAIN (link))
1534     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1535
1536   /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
1537   for (link = current_binding_level->shadowed_labels;
1538        link;
1539        link = TREE_CHAIN (link))
1540     pop_label (TREE_VALUE (link), TREE_PURPOSE (link));
1541
1542   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1543      list if a `using' declaration put them there.  The debugging
1544      back-ends won't understand OVERLOAD, so we remove them here.
1545      Because the BLOCK_VARS are (temporarily) shared with
1546      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1547      popped all the bindings.  */
1548   if (block)
1549     {
1550       tree* d;
1551
1552       for (d = &BLOCK_VARS (block); *d; )
1553         {
1554           if (TREE_CODE (*d) == TREE_LIST)
1555             *d = TREE_CHAIN (*d);
1556           else
1557             d = &TREE_CHAIN (*d);
1558         }
1559     }
1560
1561   /* If the level being exited is the top level of a function,
1562      check over all the labels.  */
1563   if (functionbody)
1564     {
1565       /* Since this is the top level block of a function, the vars are
1566          the function's parameters.  Don't leave them in the BLOCK
1567          because they are found in the FUNCTION_DECL instead.  */
1568       BLOCK_VARS (block) = 0;
1569       pop_labels (block);
1570     }
1571
1572   tmp = current_binding_level->keep;
1573
1574   pop_binding_level ();
1575   if (functionbody)
1576     DECL_INITIAL (current_function_decl) = block;
1577   else if (block)
1578     {
1579       if (!block_previously_created)
1580         current_binding_level->blocks
1581           = chainon (current_binding_level->blocks, block);
1582     }
1583   /* If we did not make a block for the level just exited,
1584      any blocks made for inner levels
1585      (since they cannot be recorded as subblocks in that level)
1586      must be carried forward so they will later become subblocks
1587      of something else.  */
1588   else if (subblocks)
1589     current_binding_level->blocks
1590       = chainon (current_binding_level->blocks, subblocks);
1591
1592   /* Each and every BLOCK node created here in `poplevel' is important
1593      (e.g. for proper debugging information) so if we created one
1594      earlier, mark it as "used".  */
1595   if (block)
1596     TREE_USED (block) = 1;
1597
1598   /* Take care of compiler's internal binding structures.  */
1599   if (tmp == 2)
1600     {
1601       tree scope_stmts;
1602
1603       scope_stmts
1604         = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1605       if (block)
1606         {
1607           SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1608           SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1609         }
1610
1611       block = poplevel (keep, reverse, functionbody);
1612     }
1613
1614   return block;
1615 }
1616
1617 /* Delete the node BLOCK from the current binding level.
1618    This is used for the block inside a stmt expr ({...})
1619    so that the block can be reinserted where appropriate.  */
1620
1621 void
1622 delete_block (block)
1623      tree block;
1624 {
1625   tree t;
1626   if (current_binding_level->blocks == block)
1627     current_binding_level->blocks = TREE_CHAIN (block);
1628   for (t = current_binding_level->blocks; t;)
1629     {
1630       if (TREE_CHAIN (t) == block)
1631         TREE_CHAIN (t) = TREE_CHAIN (block);
1632       else
1633         t = TREE_CHAIN (t);
1634     }
1635   TREE_CHAIN (block) = NULL_TREE;
1636   /* Clear TREE_USED which is always set by poplevel.
1637      The flag is set again if insert_block is called.  */
1638   TREE_USED (block) = 0;
1639 }
1640
1641 /* Insert BLOCK at the end of the list of subblocks of the
1642    current binding level.  This is used when a BIND_EXPR is expanded,
1643    to handle the BLOCK node inside the BIND_EXPR.  */
1644
1645 void
1646 insert_block (block)
1647      tree block;
1648 {
1649   TREE_USED (block) = 1;
1650   current_binding_level->blocks
1651     = chainon (current_binding_level->blocks, block);
1652 }
1653
1654 /* Set the BLOCK node for the innermost scope
1655    (the one we are currently in).  */
1656
1657 void
1658 set_block (block)
1659     register tree block;
1660 {
1661   current_binding_level->this_block = block;
1662 }
1663
1664 /* Do a pushlevel for class declarations.  */
1665
1666 void
1667 pushlevel_class ()
1668 {
1669   register struct binding_level *newlevel;
1670
1671   /* Reuse or create a struct for this binding level.  */
1672 #if defined(DEBUG_CP_BINDING_LEVELS)
1673   if (0)
1674 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1675   if (free_binding_level)
1676 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1677     {
1678       newlevel = free_binding_level;
1679       free_binding_level = free_binding_level->level_chain;
1680     }
1681   else
1682     newlevel = make_binding_level ();
1683
1684 #if defined(DEBUG_CP_BINDING_LEVELS)
1685   is_class_level = 1;
1686 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1687
1688   push_binding_level (newlevel, 0, 0);
1689
1690   class_binding_level = current_binding_level;
1691   class_binding_level->parm_flag = 2;
1692   class_binding_level->this_class = current_class_type;
1693 }
1694
1695 /* ...and a poplevel for class declarations.  */
1696
1697 void
1698 poplevel_class ()
1699 {
1700   register struct binding_level *level = class_binding_level;
1701   tree shadowed;
1702
1703   my_friendly_assert (level != 0, 354);
1704
1705   /* If we're leaving a toplevel class, don't bother to do the setting
1706      of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1707      shouldn't even be used when current_class_type isn't set, and second,
1708      if we don't touch it here, we're able to use the cache effect if the
1709      next time we're entering a class scope, it is the same class.  */
1710   if (current_class_depth != 1)
1711     {
1712       struct binding_level* b;
1713
1714       /* Clear out our IDENTIFIER_CLASS_VALUEs.  */
1715       for (shadowed = level->class_shadowed;
1716            shadowed;
1717            shadowed = TREE_CHAIN (shadowed))
1718         IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1719
1720       /* Find the next enclosing class, and recreate
1721          IDENTIFIER_CLASS_VALUEs appropriate for that class.  */
1722       b = level->level_chain;
1723       while (b && b->parm_flag != 2)
1724         b = b->level_chain;
1725
1726       if (b)
1727         for (shadowed = b->class_shadowed;
1728              shadowed;
1729              shadowed = TREE_CHAIN (shadowed))
1730           {
1731             tree t;
1732
1733             t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1734             while (t && BINDING_LEVEL (t) != b)
1735               t = TREE_CHAIN (t);
1736
1737             if (t)
1738               IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1739                 = BINDING_VALUE (t);
1740           }
1741     }
1742   else
1743     /* Remember to save what IDENTIFIER's were bound in this scope so we
1744        can recover from cache misses.  */
1745     {
1746       previous_class_type = current_class_type;
1747       previous_class_values = class_binding_level->class_shadowed;
1748     }
1749   for (shadowed = level->type_shadowed;
1750        shadowed;
1751        shadowed = TREE_CHAIN (shadowed))
1752     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1753
1754   /* Remove the bindings for all of the class-level declarations.  */
1755   for (shadowed = level->class_shadowed;
1756        shadowed;
1757        shadowed = TREE_CHAIN (shadowed))
1758     pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1759
1760   GNU_xref_end_scope ((HOST_WIDE_INT) class_binding_level,
1761                       (HOST_WIDE_INT) class_binding_level->level_chain,
1762                       class_binding_level->parm_flag,
1763                       class_binding_level->keep);
1764
1765   /* Now, pop out of the binding level which we created up in the
1766      `pushlevel_class' routine.  */
1767 #if defined(DEBUG_CP_BINDING_LEVELS)
1768   is_class_level = 1;
1769 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1770
1771   pop_binding_level ();
1772 }
1773
1774 /* We are entering the scope of a class.  Clear IDENTIFIER_CLASS_VALUE
1775    for any names in enclosing classes.  */
1776
1777 void
1778 clear_identifier_class_values ()
1779 {
1780   tree t;
1781
1782   if (!class_binding_level)
1783     return;
1784
1785   for (t = class_binding_level->class_shadowed;
1786        t;
1787        t = TREE_CHAIN (t))
1788     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1789 }
1790
1791 /* Returns non-zero if T is a virtual function table.  */
1792
1793 int
1794 vtable_decl_p (t, data)
1795      tree t;
1796      void *data ATTRIBUTE_UNUSED;
1797 {
1798   return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1799 }
1800
1801 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1802    functions.  */
1803
1804 int
1805 vtype_decl_p (t, data)
1806      tree t;
1807      void *data ATTRIBUTE_UNUSED;
1808 {
1809   return (TREE_CODE (t) == TYPE_DECL
1810           && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE
1811           && TYPE_POLYMORPHIC_P (TREE_TYPE (t)));
1812 }
1813
1814 /* Return the declarations that are members of the namespace NS.  */
1815
1816 tree
1817 cp_namespace_decls (ns)
1818      tree ns;
1819 {
1820   return NAMESPACE_LEVEL (ns)->names;
1821 }
1822
1823 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1824    itself, calling F for each.  The DATA is passed to F as well.  */
1825
1826 static int
1827 walk_namespaces_r (namespace, f, data)
1828      tree namespace;
1829      walk_namespaces_fn f;
1830      void *data;
1831 {
1832   tree current;
1833   int result = 0;
1834
1835   result |= (*f) (namespace, data);
1836
1837   for (current = cp_namespace_decls (namespace);
1838        current;
1839        current = TREE_CHAIN (current))
1840     {
1841       if (TREE_CODE (current) != NAMESPACE_DECL
1842           || DECL_NAMESPACE_ALIAS (current))
1843         continue;
1844       if (!DECL_LANG_SPECIFIC (current))
1845         {
1846           /* Hmm. std. */
1847           my_friendly_assert (current == std_node, 393);
1848           continue;
1849         }
1850
1851       /* We found a namespace.  */
1852       result |= walk_namespaces_r (current, f, data);
1853     }
1854
1855   return result;
1856 }
1857
1858 /* Walk all the namespaces, calling F for each.  The DATA is passed to
1859    F as well.  */
1860
1861 int
1862 walk_namespaces (f, data)
1863      walk_namespaces_fn f;
1864      void *data;
1865 {
1866   return walk_namespaces_r (global_namespace, f, data);
1867 }
1868
1869 struct walk_globals_data {
1870   walk_globals_pred p;
1871   walk_globals_fn f;
1872   void *data;
1873 };
1874
1875 /* Walk the global declarations in NAMESPACE.  Whenever one is found
1876    for which P returns non-zero, call F with its address.  If any call
1877    to F returns a non-zero value, return a non-zero value.  */
1878
1879 static int
1880 walk_globals_r (namespace, data)
1881      tree namespace;
1882      void *data;
1883 {
1884   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1885   walk_globals_pred p = wgd->p;
1886   walk_globals_fn f = wgd->f;
1887   void *d = wgd->data;
1888   tree *t;
1889   int result = 0;
1890
1891   t = &NAMESPACE_LEVEL (namespace)->names;
1892
1893   while (*t)
1894     {
1895       tree glbl = *t;
1896
1897       if ((*p) (glbl, d))
1898         result |= (*f) (t, d);
1899
1900       /* If F changed *T, then *T still points at the next item to
1901          examine.  */
1902       if (*t == glbl)
1903         t = &TREE_CHAIN (*t);
1904     }
1905
1906   return result;
1907 }
1908
1909 /* Walk the global declarations.  Whenever one is found for which P
1910    returns non-zero, call F with its address.  If any call to F
1911    returns a non-zero value, return a non-zero value.  */
1912
1913 int
1914 walk_globals (p, f, data)
1915      walk_globals_pred p;
1916      walk_globals_fn f;
1917      void *data;
1918 {
1919   struct walk_globals_data wgd;
1920   wgd.p = p;
1921   wgd.f = f;
1922   wgd.data = data;
1923
1924   return walk_namespaces (walk_globals_r, &wgd);
1925 }
1926
1927 /* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
1928    DATA is non-NULL, this is the last time we will call
1929    wrapup_global_declarations for this NAMESPACE.  */
1930
1931 int
1932 wrapup_globals_for_namespace (namespace, data)
1933      tree namespace;
1934      void *data;
1935 {
1936   tree globals = cp_namespace_decls (namespace);
1937   int len = list_length (globals);
1938   tree *vec = (tree *) alloca (sizeof (tree) * len);
1939   int i;
1940   int result;
1941   tree decl;
1942   int last_time = (data != 0);
1943
1944   if (last_time && namespace == global_namespace)
1945     /* Let compile_file handle the global namespace.  */
1946     return 0;
1947
1948   /* Process the decls in reverse order--earliest first.
1949      Put them into VEC from back to front, then take out from front.  */
1950
1951   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1952     {
1953       /* Pretend we've output an unused static variable.  This ensures
1954          that the toplevel __FUNCTION__ etc won't be emitted, unless
1955          needed. */
1956       if (TREE_CODE (decl) == VAR_DECL && DECL_ARTIFICIAL (decl)
1957           && !TREE_PUBLIC (decl) && !TREE_USED (decl))
1958         {
1959           TREE_ASM_WRITTEN (decl) = 1;
1960           DECL_IGNORED_P (decl) = 1;
1961         }
1962       vec[len - i - 1] = decl;
1963     }
1964
1965   if (last_time)
1966     {
1967       check_global_declarations (vec, len);
1968       return 0;
1969     }
1970
1971   /* Temporarily mark vtables as external.  That prevents
1972      wrapup_global_declarations from writing them out; we must process
1973      them ourselves in finish_vtable_vardecl.  */
1974   for (i = 0; i < len; ++i)
1975     if (vtable_decl_p (vec[i], /*data=*/0) && !DECL_EXTERNAL (vec[i]))
1976       {
1977         DECL_NOT_REALLY_EXTERN (vec[i]) = 1;
1978         DECL_EXTERNAL (vec[i]) = 1;
1979       }
1980
1981   /* Write out any globals that need to be output.  */
1982   result = wrapup_global_declarations (vec, len);
1983
1984   /* Undo the hack to DECL_EXTERNAL above.  */
1985   for (i = 0; i < len; ++i)
1986     if (vtable_decl_p (vec[i], /*data=*/0)
1987         && DECL_NOT_REALLY_EXTERN (vec[i]))
1988       {
1989         DECL_NOT_REALLY_EXTERN (vec[i]) = 0;
1990         DECL_EXTERNAL (vec[i]) = 0;
1991       }
1992
1993   return result;
1994 }
1995
1996 \f
1997 /* Mark ARG (which is really a struct binding_level **) for GC.  */
1998
1999 static void
2000 mark_binding_level (arg)
2001      void *arg;
2002 {
2003   struct binding_level *lvl = *(struct binding_level **)arg;
2004
2005   for (; lvl; lvl = lvl->level_chain)
2006     {
2007       ggc_mark_tree (lvl->names);
2008       ggc_mark_tree (lvl->tags);
2009       ggc_mark_tree (lvl->usings);
2010       ggc_mark_tree (lvl->using_directives);
2011       ggc_mark_tree (lvl->class_shadowed);
2012       ggc_mark_tree (lvl->type_shadowed);
2013       ggc_mark_tree (lvl->shadowed_labels);
2014       ggc_mark_tree (lvl->blocks);
2015       ggc_mark_tree (lvl->this_block);
2016       ggc_mark_tree (lvl->this_class);
2017       ggc_mark_tree (lvl->incomplete);
2018       ggc_mark_tree (lvl->dead_vars_from_for);
2019     }
2020 }
2021
2022 static void
2023 mark_named_label_lists (labs, uses)
2024      void *labs;
2025      void *uses;
2026 {
2027   struct named_label_list *l = *(struct named_label_list **)labs;
2028   struct named_label_use_list *u = *(struct named_label_use_list **)uses;
2029
2030   for (; l; l = l->next)
2031     {
2032       ggc_mark (l);
2033       mark_binding_level (l->binding_level);
2034       ggc_mark_tree (l->old_value);
2035       ggc_mark_tree (l->label_decl);
2036       ggc_mark_tree (l->bad_decls);
2037     }
2038
2039   for (; u; u = u->next)
2040     ggc_mark (u);
2041 }
2042 \f
2043 /* For debugging.  */
2044 static int no_print_functions = 0;
2045 static int no_print_builtins = 0;
2046
2047 void
2048 print_binding_level (lvl)
2049      struct binding_level *lvl;
2050 {
2051   tree t;
2052   int i = 0, len;
2053   fprintf (stderr, " blocks=");
2054   fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
2055   fprintf (stderr, " n_incomplete=%d parm_flag=%d keep=%d",
2056            list_length (lvl->incomplete), lvl->parm_flag, lvl->keep);
2057   if (lvl->tag_transparent)
2058     fprintf (stderr, " tag-transparent");
2059   if (lvl->more_cleanups_ok)
2060     fprintf (stderr, " more-cleanups-ok");
2061   if (lvl->have_cleanups)
2062     fprintf (stderr, " have-cleanups");
2063   fprintf (stderr, "\n");
2064   if (lvl->names)
2065     {
2066       fprintf (stderr, " names:\t");
2067       /* We can probably fit 3 names to a line?  */
2068       for (t = lvl->names; t; t = TREE_CHAIN (t))
2069         {
2070           if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
2071             continue;
2072           if (no_print_builtins
2073               && (TREE_CODE (t) == TYPE_DECL)
2074               && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
2075             continue;
2076
2077           /* Function decls tend to have longer names.  */
2078           if (TREE_CODE (t) == FUNCTION_DECL)
2079             len = 3;
2080           else
2081             len = 2;
2082           i += len;
2083           if (i > 6)
2084             {
2085               fprintf (stderr, "\n\t");
2086               i = len;
2087             }
2088           print_node_brief (stderr, "", t, 0);
2089           if (t == error_mark_node)
2090             break;
2091         }
2092       if (i)
2093         fprintf (stderr, "\n");
2094     }
2095   if (lvl->tags)
2096     {
2097       fprintf (stderr, " tags:\t");
2098       i = 0;
2099       for (t = lvl->tags; t; t = TREE_CHAIN (t))
2100         {
2101           if (TREE_PURPOSE (t) == NULL_TREE)
2102             len = 3;
2103           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2104             len = 2;
2105           else
2106             len = 4;
2107           i += len;
2108           if (i > 5)
2109             {
2110               fprintf (stderr, "\n\t");
2111               i = len;
2112             }
2113           if (TREE_PURPOSE (t) == NULL_TREE)
2114             {
2115               print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
2116               fprintf (stderr, ">");
2117             }
2118           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2119             print_node_brief (stderr, "", TREE_VALUE (t), 0);
2120           else
2121             {
2122               print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
2123               print_node_brief (stderr, "", TREE_VALUE (t), 0);
2124               fprintf (stderr, ">");
2125             }
2126         }
2127       if (i)
2128         fprintf (stderr, "\n");
2129     }
2130   if (lvl->class_shadowed)
2131     {
2132       fprintf (stderr, " class-shadowed:");
2133       for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
2134         {
2135           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2136         }
2137       fprintf (stderr, "\n");
2138     }
2139   if (lvl->type_shadowed)
2140     {
2141       fprintf (stderr, " type-shadowed:");
2142       for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
2143         {
2144           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2145         }
2146       fprintf (stderr, "\n");
2147     }
2148 }
2149
2150 void
2151 print_other_binding_stack (stack)
2152      struct binding_level *stack;
2153 {
2154   struct binding_level *level;
2155   for (level = stack; level != global_binding_level; level = level->level_chain)
2156     {
2157       fprintf (stderr, "binding level ");
2158       fprintf (stderr, HOST_PTR_PRINTF, level);
2159       fprintf (stderr, "\n");
2160       print_binding_level (level);
2161     }
2162 }
2163
2164 void
2165 print_binding_stack ()
2166 {
2167   struct binding_level *b;
2168   fprintf (stderr, "current_binding_level=");
2169   fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
2170   fprintf (stderr, "\nclass_binding_level=");
2171   fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
2172   fprintf (stderr, "\nglobal_binding_level=");
2173   fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
2174   fprintf (stderr, "\n");
2175   if (class_binding_level)
2176     {
2177       for (b = class_binding_level; b; b = b->level_chain)
2178         if (b == current_binding_level)
2179           break;
2180       if (b)
2181         b = class_binding_level;
2182       else
2183         b = current_binding_level;
2184     }
2185   else
2186     b = current_binding_level;
2187   print_other_binding_stack (b);
2188   fprintf (stderr, "global:\n");
2189   print_binding_level (global_binding_level);
2190 }
2191
2192 /* Namespace binding access routines: The namespace_bindings field of
2193    the identifier is polymorphic, with three possible values:
2194    NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2195    indicating the BINDING_VALUE of global_namespace. */
2196
2197 /* Check whether the a binding for the name to scope is known.
2198    Assumes that the bindings of the name are already a list
2199    of bindings. Returns the binding found, or NULL_TREE. */
2200
2201 static tree
2202 find_binding (name, scope)
2203      tree name;
2204      tree scope;
2205 {
2206   tree iter, prev = NULL_TREE;
2207
2208   scope = ORIGINAL_NAMESPACE (scope);
2209
2210   for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2211        iter = TREE_CHAIN (iter))
2212     {
2213       my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2214       if (BINDING_SCOPE (iter) == scope)
2215         {
2216           /* Move binding found to the front of the list, so
2217              subsequent lookups will find it faster. */
2218           if (prev)
2219             {
2220               TREE_CHAIN (prev) = TREE_CHAIN (iter);
2221               TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2222               IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2223             }
2224           return iter;
2225         }
2226       prev = iter;
2227     }
2228   return NULL_TREE;
2229 }
2230
2231 /* Always returns a binding for name in scope. If the
2232    namespace_bindings is not a list, convert it to one first.
2233    If no binding is found, make a new one. */
2234
2235 tree
2236 binding_for_name (name, scope)
2237      tree name;
2238      tree scope;
2239 {
2240   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2241   tree result;
2242
2243   scope = ORIGINAL_NAMESPACE (scope);
2244
2245   if (b && TREE_CODE (b) != CPLUS_BINDING)
2246     {
2247       /* Get rid of optimization for global scope. */
2248       IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2249       BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2250       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2251     }
2252   if (b && (result = find_binding (name, scope)))
2253     return result;
2254   /* Not found, make a new one. */
2255   result = make_node (CPLUS_BINDING);
2256   TREE_CHAIN (result) = b;
2257   IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2258   BINDING_SCOPE (result) = scope;
2259   BINDING_TYPE (result) = NULL_TREE;
2260   BINDING_VALUE (result) = NULL_TREE;
2261   return result;
2262 }
2263
2264 /* Return the binding value for name in scope, considering that
2265    namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2266
2267 tree
2268 namespace_binding (name, scope)
2269      tree name;
2270      tree scope;
2271 {
2272   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2273   if (b == NULL_TREE)
2274     return NULL_TREE;
2275   if (scope == NULL_TREE)
2276     scope = global_namespace;
2277   if (TREE_CODE (b) != CPLUS_BINDING)
2278     return (scope == global_namespace) ? b : NULL_TREE;
2279   name = find_binding (name,scope);
2280   if (name == NULL_TREE)
2281     return name;
2282   return BINDING_VALUE (name);
2283 }
2284
2285 /* Set the binding value for name in scope. If modifying the binding
2286    of global_namespace is attempted, try to optimize it. */
2287
2288 void
2289 set_namespace_binding (name, scope, val)
2290      tree name;
2291      tree scope;
2292      tree val;
2293 {
2294   tree b;
2295
2296   if (scope == NULL_TREE)
2297     scope = global_namespace;
2298
2299   if (scope == global_namespace)
2300     {
2301       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2302       if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2303         {
2304           IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2305           return;
2306         }
2307     }
2308   b = binding_for_name (name, scope);
2309   BINDING_VALUE (b) = val;
2310 }
2311
2312 /* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
2313    select a name that is unique to this compilation unit.  */
2314
2315 void
2316 push_namespace (name)
2317      tree name;
2318 {
2319   tree d = NULL_TREE;
2320   int need_new = 1;
2321   int implicit_use = 0;
2322   int global = 0;
2323   if (!global_namespace)
2324     {
2325       /* This must be ::. */
2326       my_friendly_assert (name == get_identifier ("::"), 377);
2327       global = 1;
2328     }
2329   else if (!name)
2330     {
2331       /* The name of anonymous namespace is unique for the translation
2332          unit.  */
2333       if (!anonymous_namespace_name)
2334         anonymous_namespace_name = get_file_function_name ('N');
2335       name = anonymous_namespace_name;
2336       d = IDENTIFIER_NAMESPACE_VALUE (name);
2337       if (d)
2338         /* Reopening anonymous namespace.  */
2339         need_new = 0;
2340       implicit_use = 1;
2341     }
2342   else if (current_namespace == global_namespace
2343            && name == DECL_NAME (std_node))
2344     {
2345       in_std++;
2346       return;
2347     }
2348   else
2349     {
2350       /* Check whether this is an extended namespace definition. */
2351       d = IDENTIFIER_NAMESPACE_VALUE (name);
2352       if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2353         {
2354           need_new = 0;
2355           if (DECL_NAMESPACE_ALIAS (d))
2356             {
2357               cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
2358                         d, DECL_NAMESPACE_ALIAS (d));
2359               d = DECL_NAMESPACE_ALIAS (d);
2360             }
2361         }
2362     }
2363
2364   if (need_new)
2365     {
2366       /* Make a new namespace, binding the name to it. */
2367       d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2368       /* The global namespace is not pushed, and the global binding
2369          level is set elsewhere.  */
2370       if (!global)
2371         {
2372           DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
2373           d = pushdecl (d);
2374           pushlevel (0);
2375           declare_namespace_level ();
2376           NAMESPACE_LEVEL (d) = current_binding_level;
2377         }
2378     }
2379   else
2380     resume_binding_level (NAMESPACE_LEVEL (d));
2381
2382   if (implicit_use)
2383     do_using_directive (d);
2384   /* Enter the name space. */
2385   current_namespace = d;
2386 }
2387
2388 /* Pop from the scope of the current namespace.  */
2389
2390 void
2391 pop_namespace ()
2392 {
2393   if (current_namespace == global_namespace)
2394     {
2395       my_friendly_assert (in_std>0, 980421);
2396       in_std--;
2397       return;
2398     }
2399   current_namespace = CP_DECL_CONTEXT (current_namespace);
2400   /* The binding level is not popped, as it might be re-opened later.  */
2401   suspend_binding_level ();
2402 }
2403
2404 /* Push into the scope of the namespace NS, even if it is deeply
2405    nested within another namespace.  */
2406
2407 void
2408 push_nested_namespace (ns)
2409      tree ns;
2410 {
2411   if (ns == global_namespace)
2412     push_to_top_level ();
2413   else
2414     {
2415       push_nested_namespace (CP_DECL_CONTEXT (ns));
2416       push_namespace (DECL_NAME (ns));
2417     }
2418 }
2419
2420 /* Pop back from the scope of the namespace NS, which was previously
2421    entered with push_nested_namespace.  */
2422
2423 void
2424 pop_nested_namespace (ns)
2425      tree ns;
2426 {
2427   while (ns != global_namespace)
2428     {
2429       pop_namespace ();
2430       ns = CP_DECL_CONTEXT (ns);
2431     }
2432
2433   pop_from_top_level ();
2434 }
2435
2436 \f
2437 /* Subroutines for reverting temporarily to top-level for instantiation
2438    of templates and such.  We actually need to clear out the class- and
2439    local-value slots of all identifiers, so that only the global values
2440    are at all visible.  Simply setting current_binding_level to the global
2441    scope isn't enough, because more binding levels may be pushed.  */
2442 struct saved_scope *scope_chain;
2443
2444 /* Mark ST for GC.  */
2445
2446 static void
2447 mark_stmt_tree (st)
2448      struct stmt_tree *st;
2449 {
2450   ggc_mark_tree (st->x_last_stmt);
2451   ggc_mark_tree (st->x_last_expr_type);
2452 }
2453
2454 /* Mark ARG (which is really a struct saved_scope **) for GC.  */
2455
2456 static void
2457 mark_saved_scope (arg)
2458      void *arg;
2459 {
2460   struct saved_scope *t = *(struct saved_scope **)arg;
2461   while (t)
2462     {
2463       mark_binding_level (&t->class_bindings);
2464       ggc_mark_tree (t->old_bindings);
2465       ggc_mark_tree (t->old_namespace);
2466       ggc_mark_tree (t->class_name);
2467       ggc_mark_tree (t->class_type);
2468       ggc_mark_tree (t->access_specifier);
2469       ggc_mark_tree (t->function_decl);
2470       if (t->lang_base)
2471         ggc_mark_tree_varray (t->lang_base);
2472       ggc_mark_tree (t->lang_name);
2473       ggc_mark_tree (t->x_function_parms);
2474       ggc_mark_tree (t->template_parms);
2475       ggc_mark_tree (t->x_previous_class_type);
2476       ggc_mark_tree (t->x_previous_class_values);
2477       ggc_mark_tree (t->x_saved_tree);
2478       ggc_mark_tree (t->incomplete);
2479       ggc_mark_tree (t->lookups);
2480
2481       mark_stmt_tree (&t->x_stmt_tree);
2482       mark_binding_level (&t->bindings);
2483       t = t->prev;
2484     }
2485 }
2486
2487 static tree
2488 store_bindings (names, old_bindings)
2489      tree names, old_bindings;
2490 {
2491   tree t;
2492   for (t = names; t; t = TREE_CHAIN (t))
2493     {
2494       tree binding, t1, id;
2495
2496       if (TREE_CODE (t) == TREE_LIST)
2497         id = TREE_PURPOSE (t);
2498       else
2499         id = DECL_NAME (t);
2500
2501       if (!id
2502           /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2503              we have no IDENTIFIER_BINDING if we have left the class
2504              scope, but cached the class-level declarations.  */
2505           || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2506         continue;
2507
2508       for (t1 = old_bindings; t1; t1 = TREE_CHAIN (t1))
2509         if (TREE_VEC_ELT (t1, 0) == id)
2510           goto skip_it;
2511
2512       binding = make_tree_vec (4);
2513
2514       if (id)
2515         {
2516           my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2517           TREE_VEC_ELT (binding, 0) = id;
2518           TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2519           TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2520           TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2521           IDENTIFIER_BINDING (id) = NULL_TREE;
2522           IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2523         }
2524       TREE_CHAIN (binding) = old_bindings;
2525       old_bindings = binding;
2526     skip_it:
2527       ;
2528     }
2529   return old_bindings;
2530 }
2531
2532 void
2533 maybe_push_to_top_level (pseudo)
2534      int pseudo;
2535 {
2536   struct saved_scope *s;
2537   struct binding_level *b;
2538   tree old_bindings;
2539   int need_pop;
2540
2541   s = (struct saved_scope *) xcalloc (1, sizeof (struct saved_scope));
2542
2543   b = scope_chain ? current_binding_level : 0;
2544
2545   /* If we're in the middle of some function, save our state.  */
2546   if (cfun)
2547     {
2548       need_pop = 1;
2549       push_function_context_to (NULL_TREE);
2550     }
2551   else
2552     need_pop = 0;
2553
2554   old_bindings = NULL_TREE;
2555   if (scope_chain && previous_class_type)
2556     old_bindings = store_bindings (previous_class_values, old_bindings);
2557
2558   /* Have to include global_binding_level, because class-level decls
2559      aren't listed anywhere useful.  */
2560   for (; b; b = b->level_chain)
2561     {
2562       tree t;
2563
2564       /* Template IDs are inserted into the global level. If they were
2565          inserted into namespace level, finish_file wouldn't find them
2566          when doing pending instantiations. Therefore, don't stop at
2567          namespace level, but continue until :: .  */
2568       if (b == global_binding_level || (pseudo && b->template_parms_p))
2569         break;
2570
2571       old_bindings = store_bindings (b->names, old_bindings);
2572       /* We also need to check class_shadowed to save class-level type
2573          bindings, since pushclass doesn't fill in b->names.  */
2574       if (b->parm_flag == 2)
2575         old_bindings = store_bindings (b->class_shadowed, old_bindings);
2576
2577       /* Unwind type-value slots back to top level.  */
2578       for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2579         SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2580     }
2581   s->prev = scope_chain;
2582   s->old_bindings = old_bindings;
2583   s->bindings = b;
2584   s->need_pop_function_context = need_pop;
2585   s->function_decl = current_function_decl;
2586
2587   scope_chain = s;
2588   current_function_decl = NULL_TREE;
2589   VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2590   current_lang_stack = &VARRAY_TREE (current_lang_base, 0);
2591   current_lang_name = lang_name_cplusplus;
2592   strict_prototype = strict_prototypes_lang_cplusplus;
2593   current_namespace = global_namespace;
2594 }
2595
2596 void
2597 push_to_top_level ()
2598 {
2599   maybe_push_to_top_level (0);
2600 }
2601
2602 void
2603 pop_from_top_level ()
2604 {
2605   struct saved_scope *s = scope_chain;
2606   tree t;
2607
2608   /* Clear out class-level bindings cache.  */
2609   if (previous_class_type)
2610     invalidate_class_lookup_cache ();
2611
2612   VARRAY_FREE (current_lang_base);
2613
2614   scope_chain = s->prev;
2615   for (t = s->old_bindings; t; t = TREE_CHAIN (t))
2616     {
2617       tree id = TREE_VEC_ELT (t, 0);
2618       if (id)
2619         {
2620           SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2621           IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2622           IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2623         }
2624     }
2625
2626   if (current_lang_name == lang_name_cplusplus)
2627     strict_prototype = strict_prototypes_lang_cplusplus;
2628   else if (current_lang_name == lang_name_c)
2629     strict_prototype = strict_prototypes_lang_c;
2630
2631   /* If we were in the middle of compiling a function, restore our
2632      state.  */
2633   if (s->need_pop_function_context)
2634     pop_function_context_from (NULL_TREE);
2635   current_function_decl = s->function_decl;
2636
2637   free (s);
2638 }
2639 \f
2640 /* Push a definition of struct, union or enum tag "name".
2641    into binding_level "b".   "type" should be the type node,
2642    We assume that the tag "name" is not already defined.
2643
2644    Note that the definition may really be just a forward reference.
2645    In that case, the TYPE_SIZE will be a NULL_TREE.
2646
2647    C++ gratuitously puts all these tags in the name space.  */
2648
2649 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2650    record the shadowed value for this binding contour.  TYPE is
2651    the type that ID maps to.  */
2652
2653 static void
2654 set_identifier_type_value_with_scope (id, type, b)
2655      tree id;
2656      tree type;
2657      struct binding_level *b;
2658 {
2659   if (!b->namespace_p)
2660     {
2661       /* Shadow the marker, not the real thing, so that the marker
2662          gets restored later. */
2663       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2664       b->type_shadowed
2665         = tree_cons (id, old_type_value, b->type_shadowed);
2666     }
2667   else
2668     {
2669       tree binding = binding_for_name (id, current_namespace);
2670       BINDING_TYPE (binding) = type;
2671       /* Store marker instead of real type. */
2672       type = global_type_node;
2673     }
2674   SET_IDENTIFIER_TYPE_VALUE (id, type);
2675 }
2676
2677 /* As set_identifier_type_value_with_scope, but using current_binding_level.  */
2678
2679 void
2680 set_identifier_type_value (id, type)
2681      tree id;
2682      tree type;
2683 {
2684   set_identifier_type_value_with_scope (id, type, current_binding_level);
2685 }
2686
2687 /* Return the type associated with id. */
2688
2689 tree
2690 identifier_type_value (id)
2691      tree id;
2692 {
2693   /* There is no type with that name, anywhere. */
2694   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2695     return NULL_TREE;
2696   /* This is not the type marker, but the real thing. */
2697   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2698     return REAL_IDENTIFIER_TYPE_VALUE (id);
2699   /* Have to search for it. It must be on the global level, now.
2700      Ask lookup_name not to return non-types. */
2701   id = lookup_name_real (id, 2, 1, 0);
2702   if (id)
2703     return TREE_TYPE (id);
2704   return NULL_TREE;
2705 }
2706
2707 /* Pop off extraneous binding levels left over due to syntax errors.
2708
2709    We don't pop past namespaces, as they might be valid.  */
2710
2711 void
2712 pop_everything ()
2713 {
2714 #ifdef DEBUG_CP_BINDING_LEVELS
2715   fprintf (stderr, "XXX entering pop_everything ()\n");
2716 #endif
2717   while (!toplevel_bindings_p ())
2718     {
2719       if (current_binding_level->parm_flag == 2)
2720         pop_nested_class ();
2721       else
2722         poplevel (0, 0, 0);
2723     }
2724 #ifdef DEBUG_CP_BINDING_LEVELS
2725   fprintf (stderr, "XXX leaving pop_everything ()\n");
2726 #endif
2727 }
2728
2729 /* The type TYPE is being declared.  If it is a class template, or a
2730    specialization of a class template, do any processing required and
2731    perform error-checking.  If IS_FRIEND is non-zero, this TYPE is
2732    being declared a friend.  B is the binding level at which this TYPE
2733    should be bound.
2734
2735    Returns the TYPE_DECL for TYPE, which may have been altered by this
2736    processing.  */
2737
2738 static tree
2739 maybe_process_template_type_declaration (type, globalize, b)
2740      tree type;
2741      int globalize;
2742      struct binding_level* b;
2743 {
2744   tree decl = TYPE_NAME (type);
2745
2746   if (processing_template_parmlist)
2747     /* You can't declare a new template type in a template parameter
2748        list.  But, you can declare a non-template type:
2749
2750          template <class A*> struct S;
2751
2752        is a forward-declaration of `A'.  */
2753     ;
2754   else
2755     {
2756       maybe_check_template_type (type);
2757
2758       my_friendly_assert (IS_AGGR_TYPE (type)
2759                           || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2760
2761
2762       if (processing_template_decl)
2763         {
2764           /* This may change after the call to
2765              push_template_decl_real, but we want the original value.  */
2766           tree name = DECL_NAME (decl);
2767
2768           decl = push_template_decl_real (decl, globalize);
2769           /* If the current binding level is the binding level for the
2770              template parameters (see the comment in
2771              begin_template_parm_list) and the enclosing level is a class
2772              scope, and we're not looking at a friend, push the
2773              declaration of the member class into the class scope.  In the
2774              friend case, push_template_decl will already have put the
2775              friend into global scope, if appropriate.  */
2776           if (TREE_CODE (type) != ENUMERAL_TYPE
2777               && !globalize && b->template_parms_p
2778               && b->level_chain->parm_flag == 2)
2779             {
2780               finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2781               /* Put this tag on the list of tags for the class, since
2782                  that won't happen below because B is not the class
2783                  binding level, but is instead the pseudo-global level.  */
2784               b->level_chain->tags =
2785                 tree_cons (name, type, b->level_chain->tags);
2786               if (!COMPLETE_TYPE_P (current_class_type))
2787                 CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2788             }
2789         }
2790     }
2791
2792   return decl;
2793 }
2794
2795 /* In C++, you don't have to write `struct S' to refer to `S'; you
2796    can just use `S'.  We accomplish this by creating a TYPE_DECL as
2797    if the user had written `typedef struct S S'.  Create and return
2798    the TYPE_DECL for TYPE.  */
2799
2800 tree
2801 create_implicit_typedef (name, type)
2802      tree name;
2803      tree type;
2804 {
2805   tree decl;
2806
2807   decl = build_decl (TYPE_DECL, name, type);
2808   DECL_ARTIFICIAL (decl) = 1;
2809   /* There are other implicit type declarations, like the one *within*
2810      a class that allows you to write `S::S'.  We must distinguish
2811      amongst these.  */
2812   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2813   TYPE_NAME (type) = decl;
2814
2815   return decl;
2816 }
2817
2818 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2819    Normally put it into the inner-most non-tag-transparent scope,
2820    but if GLOBALIZE is true, put it in the inner-most non-class scope.
2821    The latter is needed for implicit declarations.  */
2822
2823 void
2824 pushtag (name, type, globalize)
2825      tree name, type;
2826      int globalize;
2827 {
2828   register struct binding_level *b;
2829
2830   b = current_binding_level;
2831   while (b->tag_transparent
2832          || (globalize && b->parm_flag == 2))
2833     b = b->level_chain;
2834
2835   b->tags = tree_cons (name, type, b->tags);
2836
2837   if (name)
2838     {
2839       /* Do C++ gratuitous typedefing.  */
2840       if (IDENTIFIER_TYPE_VALUE (name) != type)
2841         {
2842           register tree d = NULL_TREE;
2843           int in_class = 0;
2844           tree context = TYPE_CONTEXT (type);
2845
2846           if (! context)
2847             {
2848               tree cs = current_scope ();
2849
2850               if (! globalize)
2851                 context = cs;
2852               else if (cs != NULL_TREE && TYPE_P (cs))
2853                 /* When declaring a friend class of a local class, we want
2854                    to inject the newly named class into the scope
2855                    containing the local class, not the namespace scope.  */
2856                 context = decl_function_context (get_type_decl (cs));
2857             }
2858           if (!context)
2859             context = current_namespace;
2860
2861           if ((b->template_parms_p && b->level_chain->parm_flag == 2)
2862               || b->parm_flag == 2)
2863             in_class = 1;
2864
2865           if (current_lang_name == lang_name_java)
2866             TYPE_FOR_JAVA (type) = 1;
2867
2868           d = create_implicit_typedef (name, type);
2869           DECL_CONTEXT (d) = FROB_CONTEXT (context);
2870           if (! in_class)
2871             set_identifier_type_value_with_scope (name, type, b);
2872
2873           d = maybe_process_template_type_declaration (type,
2874                                                        globalize, b);
2875
2876           if (b->parm_flag == 2)
2877             {
2878               if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2879                 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2880                    class.  But if it's a member template class, we
2881                    want the TEMPLATE_DECL, not the TYPE_DECL, so this
2882                    is done later.  */
2883                 finish_member_declaration (d);
2884               else
2885                 pushdecl_class_level (d);
2886             }
2887           else
2888             d = pushdecl_with_scope (d, b);
2889
2890           if (ANON_AGGRNAME_P (name))
2891             DECL_IGNORED_P (d) = 1;
2892
2893           TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2894           DECL_ASSEMBLER_NAME (d) = DECL_NAME (d);
2895
2896           /* If this is a local class, keep track of it.  We need this
2897              information for name-mangling, and so that it is possible to find
2898              all function definitions in a translation unit in a convenient
2899              way.  (It's otherwise tricky to find a member function definition
2900              it's only pointed to from within a local class.)  */
2901           if (TYPE_CONTEXT (type)
2902               && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL)
2903             VARRAY_PUSH_TREE (local_classes, type);
2904
2905           if (!uses_template_parms (type))
2906             {
2907               if (flag_new_abi)
2908                 DECL_ASSEMBLER_NAME (d) = mangle_type (type);
2909               else
2910                 DECL_ASSEMBLER_NAME (d)
2911                   = get_identifier (build_overload_name (type, 1, 1));
2912             }
2913         }
2914       if (b->parm_flag == 2)
2915         {
2916           if (!COMPLETE_TYPE_P (current_class_type))
2917             CLASSTYPE_TAGS (current_class_type) = b->tags;
2918         }
2919     }
2920
2921   if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2922     /* Use the canonical TYPE_DECL for this node.  */
2923     TYPE_STUB_DECL (type) = TYPE_NAME (type);
2924   else
2925     {
2926       /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2927          will be the tagged type we just added to the current
2928          binding level.  This fake NULL-named TYPE_DECL node helps
2929          dwarfout.c to know when it needs to output a
2930          representation of a tagged type, and it also gives us a
2931          convenient place to record the "scope start" address for
2932          the tagged type.  */
2933
2934       tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2935       TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2936     }
2937 }
2938
2939 /* Counter used to create anonymous type names.  */
2940
2941 static int anon_cnt = 0;
2942
2943 /* Return an IDENTIFIER which can be used as a name for
2944    anonymous structs and unions.  */
2945
2946 tree
2947 make_anon_name ()
2948 {
2949   char buf[32];
2950
2951   sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2952   return get_identifier (buf);
2953 }
2954
2955 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2956    This keeps dbxout from getting confused.  */
2957
2958 void
2959 clear_anon_tags ()
2960 {
2961   register struct binding_level *b;
2962   register tree tags;
2963   static int last_cnt = 0;
2964
2965   /* Fast out if no new anon names were declared.  */
2966   if (last_cnt == anon_cnt)
2967     return;
2968
2969   b = current_binding_level;
2970   while (b->tag_transparent)
2971     b = b->level_chain;
2972   tags = b->tags;
2973   while (tags)
2974     {
2975       /* A NULL purpose means we have already processed all tags
2976          from here to the end of the list.  */
2977       if (TREE_PURPOSE (tags) == NULL_TREE)
2978         break;
2979       if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2980         TREE_PURPOSE (tags) = NULL_TREE;
2981       tags = TREE_CHAIN (tags);
2982     }
2983   last_cnt = anon_cnt;
2984 }
2985 \f
2986 /* Subroutine of duplicate_decls: return truthvalue of whether
2987    or not types of these decls match.
2988
2989    For C++, we must compare the parameter list so that `int' can match
2990    `int&' in a parameter position, but `int&' is not confused with
2991    `const int&'.  */
2992
2993 int
2994 decls_match (newdecl, olddecl)
2995      tree newdecl, olddecl;
2996 {
2997   int types_match;
2998
2999   if (newdecl == olddecl)
3000     return 1;
3001
3002   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
3003     /* If the two DECLs are not even the same kind of thing, we're not
3004        interested in their types.  */
3005     return 0;
3006
3007   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3008     {
3009       tree f1 = TREE_TYPE (newdecl);
3010       tree f2 = TREE_TYPE (olddecl);
3011       tree p1 = TYPE_ARG_TYPES (f1);
3012       tree p2 = TYPE_ARG_TYPES (f2);
3013
3014       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
3015           && ! (DECL_EXTERN_C_P (newdecl)
3016                 && DECL_EXTERN_C_P (olddecl)))
3017         return 0;
3018
3019       if (TREE_CODE (f1) != TREE_CODE (f2))
3020         return 0;
3021
3022       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
3023         {
3024           if ((! strict_prototypes_lang_c || DECL_BUILT_IN (olddecl))
3025               && DECL_EXTERN_C_P (olddecl)
3026               && p2 == NULL_TREE)
3027             {
3028               types_match = self_promoting_args_p (p1);
3029               if (p1 == void_list_node)
3030                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
3031             }
3032           else if (!strict_prototypes_lang_c
3033                    && DECL_EXTERN_C_P (olddecl)
3034                    && DECL_EXTERN_C_P (newdecl)
3035                    && p1 == NULL_TREE)
3036             {
3037               types_match = self_promoting_args_p (p2);
3038               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
3039             }
3040           else
3041             types_match = compparms (p1, p2);
3042         }
3043       else
3044         types_match = 0;
3045     }
3046   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3047     {
3048       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3049                                 DECL_TEMPLATE_PARMS (olddecl)))
3050         return 0;
3051
3052       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3053         types_match = 1;
3054       else
3055         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
3056                                    DECL_TEMPLATE_RESULT (newdecl));
3057     }
3058   else
3059     {
3060       if (TREE_TYPE (newdecl) == error_mark_node)
3061         types_match = TREE_TYPE (olddecl) == error_mark_node;
3062       else if (TREE_TYPE (olddecl) == NULL_TREE)
3063         types_match = TREE_TYPE (newdecl) == NULL_TREE;
3064       else if (TREE_TYPE (newdecl) == NULL_TREE)
3065         types_match = 0;
3066       else
3067         types_match = comptypes (TREE_TYPE (newdecl),
3068                                  TREE_TYPE (olddecl),
3069                                  COMPARE_REDECLARATION);
3070     }
3071
3072   return types_match;
3073 }
3074
3075 /* If NEWDECL is `static' and an `extern' was seen previously,
3076    warn about it.  OLDDECL is the previous declaration.
3077
3078    Note that this does not apply to the C++ case of declaring
3079    a variable `extern const' and then later `const'.
3080
3081    Don't complain about built-in functions, since they are beyond
3082    the user's control.  */
3083
3084 static void
3085 warn_extern_redeclared_static (newdecl, olddecl)
3086      tree newdecl, olddecl;
3087 {
3088   static const char *explicit_extern_static_warning
3089     = "`%D' was declared `extern' and later `static'";
3090   static const char *implicit_extern_static_warning
3091     = "`%D' was declared implicitly `extern' and later `static'";
3092
3093   tree name;
3094
3095   if (TREE_CODE (newdecl) == TYPE_DECL
3096       || TREE_CODE (newdecl) == TEMPLATE_DECL
3097       || TREE_CODE (newdecl) == CONST_DECL)
3098     return;
3099
3100   /* Don't get confused by static member functions; that's a different
3101      use of `static'.  */
3102   if (TREE_CODE (newdecl) == FUNCTION_DECL
3103       && DECL_STATIC_FUNCTION_P (newdecl))
3104     return;
3105
3106   /* If the old declaration was `static', or the new one isn't, then
3107      then everything is OK.  */
3108   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
3109     return;
3110
3111   /* It's OK to declare a builtin function as `static'.  */
3112   if (TREE_CODE (olddecl) == FUNCTION_DECL
3113       && DECL_ARTIFICIAL (olddecl))
3114     return;
3115
3116   name = DECL_ASSEMBLER_NAME (newdecl);
3117   cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
3118               ? implicit_extern_static_warning
3119               : explicit_extern_static_warning, newdecl);
3120   cp_pedwarn_at ("previous declaration of `%D'", olddecl);
3121 }
3122
3123 /* Handle when a new declaration NEWDECL has the same name as an old
3124    one OLDDECL in the same binding contour.  Prints an error message
3125    if appropriate.
3126
3127    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
3128    Otherwise, return 0.  */
3129
3130 int
3131 duplicate_decls (newdecl, olddecl)
3132      tree newdecl, olddecl;
3133 {
3134   unsigned olddecl_uid = DECL_UID (olddecl);
3135   int olddecl_friend = 0, types_match = 0;
3136   int new_defines_function = 0;
3137
3138   if (newdecl == olddecl)
3139     return 1;
3140
3141   types_match = decls_match (newdecl, olddecl);
3142
3143   /* If either the type of the new decl or the type of the old decl is an
3144      error_mark_node, then that implies that we have already issued an
3145      error (earlier) for some bogus type specification, and in that case,
3146      it is rather pointless to harass the user with yet more error message
3147      about the same declaration, so just pretend the types match here.  */
3148   if (TREE_TYPE (newdecl) == error_mark_node
3149       || TREE_TYPE (olddecl) == error_mark_node)
3150     types_match = 1;
3151
3152   /* Check for redeclaration and other discrepancies. */
3153   if (TREE_CODE (olddecl) == FUNCTION_DECL
3154       && DECL_ARTIFICIAL (olddecl))
3155     {
3156       if (TREE_CODE (newdecl) != FUNCTION_DECL)
3157         {
3158           /* If you declare a built-in or predefined function name as static,
3159              the old definition is overridden, but optionally warn this was a
3160              bad choice of name.  */
3161           if (! TREE_PUBLIC (newdecl))
3162             {
3163               if (warn_shadow)
3164                 cp_warning ("shadowing %s function `%#D'",
3165                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3166                             olddecl);
3167               /* Discard the old built-in function.  */
3168               return 0;
3169             }
3170           /* If the built-in is not ansi, then programs can override
3171              it even globally without an error.  */
3172           else if (! DECL_BUILT_IN (olddecl))
3173             cp_warning ("library function `%#D' redeclared as non-function `%#D'",
3174                         olddecl, newdecl);
3175           else
3176             {
3177               cp_error ("declaration of `%#D'", newdecl);
3178               cp_error ("conflicts with built-in declaration `%#D'",
3179                         olddecl);
3180             }
3181           return 0;
3182         }
3183       else if (!types_match)
3184         {
3185           if ((DECL_EXTERN_C_P (newdecl)
3186                && DECL_EXTERN_C_P (olddecl))
3187               || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3188                             TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3189             {
3190               /* A near match; override the builtin.  */
3191
3192               if (TREE_PUBLIC (newdecl))
3193                 {
3194                   cp_warning ("new declaration `%#D'", newdecl);
3195                   cp_warning ("ambiguates built-in declaration `%#D'",
3196                               olddecl);
3197                 }
3198               else if (warn_shadow)
3199                 cp_warning ("shadowing %s function `%#D'",
3200                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3201                             olddecl);
3202             }
3203           else
3204             /* Discard the old built-in function.  */
3205             return 0;
3206         }
3207
3208       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3209         {
3210           /* If a builtin function is redeclared as `static', merge
3211              the declarations, but make the original one static.  */
3212           DECL_THIS_STATIC (olddecl) = 1;
3213           TREE_PUBLIC (olddecl) = 0;
3214
3215           /* Make the old declaration consistent with the new one so
3216              that all remnants of the builtin-ness of this function
3217              will be banished.  */
3218           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3219           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3220           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3221           SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (newdecl),
3222                                        newdecl);
3223         }
3224     }
3225   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3226     {
3227       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3228            && TREE_CODE (newdecl) != TYPE_DECL
3229            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3230                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3231           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3232               && TREE_CODE (olddecl) != TYPE_DECL
3233               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3234                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3235                         == TYPE_DECL))))
3236         {
3237           /* We do nothing special here, because C++ does such nasty
3238              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
3239              get shadowed, and know that if we need to find a TYPE_DECL
3240              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3241              slot of the identifier.  */
3242           return 0;
3243         }
3244
3245       if ((TREE_CODE (newdecl) == FUNCTION_DECL
3246            && DECL_FUNCTION_TEMPLATE_P (olddecl))
3247           || (TREE_CODE (olddecl) == FUNCTION_DECL
3248               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3249         return 0;
3250
3251       cp_error ("`%#D' redeclared as different kind of symbol", newdecl);
3252       if (TREE_CODE (olddecl) == TREE_LIST)
3253         olddecl = TREE_VALUE (olddecl);
3254       cp_error_at ("previous declaration of `%#D'", olddecl);
3255
3256       /* New decl is completely inconsistent with the old one =>
3257          tell caller to replace the old one.  */
3258
3259       return 0;
3260     }
3261   else if (!types_match)
3262     {
3263       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
3264         /* These are certainly not duplicate declarations; they're
3265            from different scopes.  */
3266         return 0;
3267
3268       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3269         {
3270           /* The name of a class template may not be declared to refer to
3271              any other template, class, function, object, namespace, value,
3272              or type in the same scope.  */
3273           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3274               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3275             {
3276               cp_error ("declaration of template `%#D'", newdecl);
3277               cp_error_at ("conflicts with previous declaration `%#D'",
3278                            olddecl);
3279             }
3280           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3281                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3282                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3283                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3284                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3285                                            DECL_TEMPLATE_PARMS (olddecl)))
3286             {
3287               cp_error ("new declaration `%#D'", newdecl);
3288               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3289             }
3290           return 0;
3291         }
3292       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3293         {
3294           if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
3295             {
3296               cp_error ("declaration of C function `%#D' conflicts with",
3297                         newdecl);
3298               cp_error_at ("previous declaration `%#D' here", olddecl);
3299             }
3300           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3301                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3302             {
3303               cp_error ("new declaration `%#D'", newdecl);
3304               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3305             }
3306           else
3307             return 0;
3308         }
3309
3310       /* Already complained about this, so don't do so again.  */
3311       else if (current_class_type == NULL_TREE
3312           || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3313         {
3314           cp_error ("conflicting types for `%#D'", newdecl);
3315           cp_error_at ("previous declaration as `%#D'", olddecl);
3316         }
3317     }
3318   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3319             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3320                  && (!DECL_TEMPLATE_INFO (newdecl)
3321                      || (DECL_TI_TEMPLATE (newdecl)
3322                          != DECL_TI_TEMPLATE (olddecl))))
3323                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3324                     && (!DECL_TEMPLATE_INFO (olddecl)
3325                         || (DECL_TI_TEMPLATE (olddecl)
3326                             != DECL_TI_TEMPLATE (newdecl))))))
3327     /* It's OK to have a template specialization and a non-template
3328        with the same type, or to have specializations of two
3329        different templates with the same type.  Note that if one is a
3330        specialization, and the other is an instantiation of the same
3331        template, that we do not exit at this point.  That situation
3332        can occur if we instantiate a template class, and then
3333        specialize one of its methods.  This situation is legal, but
3334        the declarations must be merged in the usual way.  */
3335     return 0;
3336   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3337            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3338                 && !DECL_USE_TEMPLATE (newdecl))
3339                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3340                    && !DECL_USE_TEMPLATE (olddecl))))
3341     /* One of the declarations is a template instantiation, and the
3342        other is not a template at all.  That's OK.  */
3343     return 0;
3344   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3345            && DECL_NAMESPACE_ALIAS (newdecl)
3346            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3347     /* Redeclaration of namespace alias, ignore it. */
3348     return 1;
3349   else
3350     {
3351       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3352       if (errmsg)
3353         {
3354           cp_error (errmsg, newdecl);
3355           if (DECL_NAME (olddecl) != NULL_TREE)
3356             cp_error_at ((DECL_INITIAL (olddecl)
3357                           && namespace_bindings_p ())
3358                          ? "`%#D' previously defined here"
3359                          : "`%#D' previously declared here", olddecl);
3360         }
3361       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3362                && DECL_INITIAL (olddecl) != NULL_TREE
3363                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3364                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3365         {
3366           /* Prototype decl follows defn w/o prototype.  */
3367           cp_warning_at ("prototype for `%#D'", newdecl);
3368           cp_warning_at ("follows non-prototype definition here", olddecl);
3369         }
3370       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3371                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3372         {
3373           /* extern "C" int foo ();
3374              int foo () { bar (); }
3375              is OK.  */
3376           if (current_lang_stack
3377               == &VARRAY_TREE (current_lang_base, 0))
3378             DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3379           else
3380             {
3381               cp_error_at ("previous declaration of `%#D' with %L linkage",
3382                            olddecl, DECL_LANGUAGE (olddecl));
3383               cp_error ("conflicts with new declaration with %L linkage",
3384                         DECL_LANGUAGE (newdecl));
3385             }
3386         }
3387
3388       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3389         ;
3390       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3391         {
3392           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3393           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3394           int i = 1;
3395
3396           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3397             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3398
3399           for (; t1 && t1 != void_list_node;
3400                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3401             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3402               {
3403                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3404                                            TREE_PURPOSE (t2)))
3405                   {
3406                     if (pedantic)
3407                       {
3408                         cp_pedwarn ("default argument given for parameter %d of `%#D'",
3409                                     i, newdecl);
3410                         cp_pedwarn_at ("after previous specification in `%#D'",
3411                                        olddecl);
3412                       }
3413                   }
3414                 else
3415                   {
3416                     cp_error ("default argument given for parameter %d of `%#D'",
3417                               i, newdecl);
3418                     cp_error_at ("after previous specification in `%#D'",
3419                                  olddecl);
3420                   }
3421               }
3422
3423           if (DECL_THIS_INLINE (newdecl) && ! DECL_THIS_INLINE (olddecl)
3424               && TREE_ADDRESSABLE (olddecl) && warn_inline)
3425             {
3426               cp_warning ("`%#D' was used before it was declared inline",
3427                           newdecl);
3428               cp_warning_at ("previous non-inline declaration here",
3429                              olddecl);
3430             }
3431         }
3432     }
3433
3434   /* If new decl is `static' and an `extern' was seen previously,
3435      warn about it.  */
3436   warn_extern_redeclared_static (newdecl, olddecl);
3437
3438   /* We have committed to returning 1 at this point.  */
3439   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3440     {
3441       /* Now that functions must hold information normally held
3442          by field decls, there is extra work to do so that
3443          declaration information does not get destroyed during
3444          definition.  */
3445       if (DECL_VINDEX (olddecl))
3446         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3447       if (DECL_VIRTUAL_CONTEXT (olddecl))
3448         DECL_VIRTUAL_CONTEXT (newdecl) = DECL_VIRTUAL_CONTEXT (olddecl);
3449       if (DECL_CONTEXT (olddecl))
3450         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3451       if (DECL_PENDING_INLINE_INFO (newdecl) == (struct pending_inline *)0)
3452         DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3453       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3454       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3455       DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3456       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3457       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3458       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3459       DECL_LANG_SPECIFIC (newdecl)->u2 = DECL_LANG_SPECIFIC (olddecl)->u2;
3460       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3461
3462       /* Optionally warn about more than one declaration for the same
3463          name, but don't warn about a function declaration followed by a
3464          definition.  */
3465       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3466           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3467           /* Don't warn about extern decl followed by definition. */
3468           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3469           /* Don't warn about friends, let add_friend take care of it. */
3470           && ! DECL_FRIEND_P (newdecl))
3471         {
3472           cp_warning ("redundant redeclaration of `%D' in same scope", newdecl);
3473           cp_warning_at ("previous declaration of `%D'", olddecl);
3474         }
3475     }
3476
3477   /* Deal with C++: must preserve virtual function table size.  */
3478   if (TREE_CODE (olddecl) == TYPE_DECL)
3479     {
3480       register tree newtype = TREE_TYPE (newdecl);
3481       register tree oldtype = TREE_TYPE (olddecl);
3482
3483       if (newtype != error_mark_node && oldtype != error_mark_node
3484           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3485         {
3486           CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
3487           CLASSTYPE_FRIEND_CLASSES (newtype)
3488             = CLASSTYPE_FRIEND_CLASSES (oldtype);
3489         }
3490
3491       DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
3492     }
3493
3494   /* Copy all the DECL_... slots specified in the new decl
3495      except for any that we copy here from the old type.  */
3496   DECL_MACHINE_ATTRIBUTES (newdecl)
3497     = merge_machine_decl_attributes (olddecl, newdecl);
3498
3499   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3500     {
3501       if (! duplicate_decls (DECL_TEMPLATE_RESULT (newdecl),
3502                              DECL_TEMPLATE_RESULT (olddecl)))
3503         cp_error ("invalid redeclaration of %D", newdecl);
3504       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3505       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3506         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3507                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3508
3509       return 1;
3510     }
3511
3512   if (types_match)
3513     {
3514       /* Automatically handles default parameters.  */
3515       tree oldtype = TREE_TYPE (olddecl);
3516       tree newtype;
3517
3518       /* Merge the data types specified in the two decls.  */
3519       newtype = common_type (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3520
3521       if (TREE_CODE (newdecl) == VAR_DECL)
3522         DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3523       /* Do this after calling `common_type' so that default
3524          parameters don't confuse us.  */
3525       else if (TREE_CODE (newdecl) == FUNCTION_DECL
3526           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3527               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3528         {
3529           TREE_TYPE (newdecl) = build_exception_variant (newtype,
3530                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3531           TREE_TYPE (olddecl) = build_exception_variant (newtype,
3532                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
3533
3534           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3535               && DECL_SOURCE_LINE (olddecl) != 0
3536               && flag_exceptions
3537               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3538                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3539             {
3540               cp_error ("declaration of `%F' throws different exceptions",
3541                         newdecl);
3542               cp_error_at ("than previous declaration `%F'", olddecl);
3543             }
3544         }
3545       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3546
3547       /* Lay the type out, unless already done.  */
3548       if (! same_type_p (newtype, oldtype)
3549           && TREE_TYPE (newdecl) != error_mark_node
3550           && !(processing_template_decl && uses_template_parms (newdecl)))
3551         layout_type (TREE_TYPE (newdecl));
3552
3553       if ((TREE_CODE (newdecl) == VAR_DECL
3554            || TREE_CODE (newdecl) == PARM_DECL
3555            || TREE_CODE (newdecl) == RESULT_DECL
3556            || TREE_CODE (newdecl) == FIELD_DECL
3557            || TREE_CODE (newdecl) == TYPE_DECL)
3558           && !(processing_template_decl && uses_template_parms (newdecl)))
3559         layout_decl (newdecl, 0);
3560
3561       /* Merge the type qualifiers.  */
3562       if (TREE_READONLY (newdecl))
3563         TREE_READONLY (olddecl) = 1;
3564       if (TREE_THIS_VOLATILE (newdecl))
3565         TREE_THIS_VOLATILE (olddecl) = 1;
3566
3567       /* Merge the initialization information.  */
3568       if (DECL_INITIAL (newdecl) == NULL_TREE
3569           && DECL_INITIAL (olddecl) != NULL_TREE)
3570         {
3571           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3572           DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
3573           DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
3574           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3575               && DECL_LANG_SPECIFIC (newdecl)
3576               && DECL_LANG_SPECIFIC (olddecl))
3577             DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3578         }
3579
3580       /* Merge the section attribute.
3581          We want to issue an error if the sections conflict but that must be
3582          done later in decl_attributes since we are called before attributes
3583          are assigned.  */
3584       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3585         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3586
3587       /* Keep the old rtl since we can safely use it.  */
3588       DECL_RTL (newdecl) = DECL_RTL (olddecl);
3589
3590       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3591         {
3592           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3593             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3594           DECL_NO_CHECK_MEMORY_USAGE (newdecl)
3595             |= DECL_NO_CHECK_MEMORY_USAGE (olddecl);
3596           DECL_NO_LIMIT_STACK (newdecl)
3597             |= DECL_NO_LIMIT_STACK (olddecl);
3598         }
3599     }
3600   /* If cannot merge, then use the new type and qualifiers,
3601      and don't preserve the old rtl.  */
3602   else
3603     {
3604       /* Clean out any memory we had of the old declaration.  */
3605       tree oldstatic = value_member (olddecl, static_aggregates);
3606       if (oldstatic)
3607         TREE_VALUE (oldstatic) = error_mark_node;
3608
3609       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3610       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3611       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3612       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3613     }
3614
3615   /* Merge the storage class information.  */
3616   DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
3617   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3618   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3619   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3620   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3621   if (! DECL_EXTERNAL (olddecl))
3622     DECL_EXTERNAL (newdecl) = 0;
3623
3624   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3625     {
3626       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3627       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3628       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3629       DECL_TEMPLATE_INSTANTIATED (newdecl)
3630         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3631       /* Don't really know how much of the language-specific
3632          values we should copy from old to new.  */
3633       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3634       DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
3635       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3636       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3637       olddecl_friend = DECL_FRIEND_P (olddecl);
3638
3639       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
3640       if (TREE_CODE (newdecl) == FUNCTION_DECL
3641           || DECL_FUNCTION_TEMPLATE_P (newdecl))
3642         DECL_BEFRIENDING_CLASSES (newdecl)
3643           = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3644                      DECL_BEFRIENDING_CLASSES (olddecl));
3645     }
3646
3647   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3648     {
3649       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3650           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3651         {
3652           /* If newdecl is not a specialization, then it is not a
3653              template-related function at all.  And that means that we
3654              shoud have exited above, returning 0.  */
3655           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3656                               0);
3657
3658           if (TREE_USED (olddecl))
3659             /* From [temp.expl.spec]:
3660
3661                If a template, a member template or the member of a class
3662                template is explicitly specialized then that
3663                specialization shall be declared before the first use of
3664                that specialization that would cause an implicit
3665                instantiation to take place, in every translation unit in
3666                which such a use occurs.  */
3667             cp_error ("explicit specialization of %D after first use",
3668                       olddecl);
3669
3670           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3671         }
3672       DECL_THIS_INLINE (newdecl) |= DECL_THIS_INLINE (olddecl);
3673
3674       /* If either decl says `inline', this fn is inline, unless its
3675          definition was passed already.  */
3676       if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3677         DECL_INLINE (olddecl) = 1;
3678       DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3679
3680       if (! types_match)
3681         {
3682           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3683           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3684           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3685         }
3686       if (! types_match || new_defines_function)
3687         {
3688           /* These need to be copied so that the names are available.
3689              Note that if the types do match, we'll preserve inline
3690              info and other bits, but if not, we won't.  */
3691           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3692           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3693         }
3694       if (new_defines_function)
3695         /* If defining a function declared with other language
3696            linkage, use the previously declared language linkage.  */
3697         DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3698       else if (types_match)
3699         {
3700           /* If redeclaring a builtin function, and not a definition,
3701              it stays built in.  */
3702           if (DECL_BUILT_IN (olddecl))
3703             {
3704               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3705               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3706               /* If we're keeping the built-in definition, keep the rtl,
3707                  regardless of declaration matches.  */
3708               DECL_RTL (newdecl) = DECL_RTL (olddecl);
3709             }
3710           else
3711             DECL_FRAME_SIZE (newdecl) = DECL_FRAME_SIZE (olddecl);
3712
3713           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3714           if ((DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl)))
3715             /* Previously saved insns go together with
3716                the function's previous definition.  */
3717             DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3718           /* Don't clear out the arguments if we're redefining a function.  */
3719           if (DECL_ARGUMENTS (olddecl))
3720             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3721         }
3722     }
3723
3724   if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3725     {
3726       NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3727     }
3728
3729   /* Now preserve various other info from the definition.  */
3730   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3731   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3732   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3733   DECL_ASSEMBLER_NAME (newdecl) = DECL_ASSEMBLER_NAME (olddecl);
3734
3735   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3736     {
3737       int function_size;
3738
3739       function_size = sizeof (struct tree_decl);
3740
3741       bcopy ((char *) newdecl + sizeof (struct tree_common),
3742              (char *) olddecl + sizeof (struct tree_common),
3743              function_size - sizeof (struct tree_common));
3744
3745       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3746         {
3747           /* If newdecl is a template instantiation, it is possible that
3748              the following sequence of events has occurred:
3749
3750              o A friend function was declared in a class template.  The
3751              class template was instantiated.
3752
3753              o The instantiation of the friend declaration was
3754              recorded on the instantiation list, and is newdecl.
3755
3756              o Later, however, instantiate_class_template called pushdecl
3757              on the newdecl to perform name injection.  But, pushdecl in
3758              turn called duplicate_decls when it discovered that another
3759              declaration of a global function with the same name already
3760              existed.
3761
3762              o Here, in duplicate_decls, we decided to clobber newdecl.
3763
3764              If we're going to do that, we'd better make sure that
3765              olddecl, and not newdecl, is on the list of
3766              instantiations so that if we try to do the instantiation
3767              again we won't get the clobbered declaration.  */
3768
3769           tree tmpl = DECL_TI_TEMPLATE (newdecl);
3770           tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3771
3772           for (; decls; decls = TREE_CHAIN (decls))
3773             if (TREE_VALUE (decls) == newdecl)
3774               TREE_VALUE (decls) = olddecl;
3775         }
3776     }
3777   else
3778     {
3779       bcopy ((char *) newdecl + sizeof (struct tree_common),
3780              (char *) olddecl + sizeof (struct tree_common),
3781              sizeof (struct tree_decl) - sizeof (struct tree_common)
3782              + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
3783     }
3784
3785   DECL_UID (olddecl) = olddecl_uid;
3786   if (olddecl_friend)
3787     DECL_FRIEND_P (olddecl) = 1;
3788
3789   /* NEWDECL contains the merged attribute lists.
3790      Update OLDDECL to be the same.  */
3791   DECL_MACHINE_ATTRIBUTES (olddecl) = DECL_MACHINE_ATTRIBUTES (newdecl);
3792
3793   return 1;
3794 }
3795
3796 /* Record a decl-node X as belonging to the current lexical scope.
3797    Check for errors (such as an incompatible declaration for the same
3798    name already seen in the same scope).
3799
3800    Returns either X or an old decl for the same name.
3801    If an old decl is returned, it may have been smashed
3802    to agree with what X says.  */
3803
3804 tree
3805 pushdecl (x)
3806      tree x;
3807 {
3808   register tree t;
3809   register tree name;
3810   int need_new_binding;
3811
3812   /* We shouldn't be calling pushdecl when we're generating RTL for a
3813      function that we already did semantic analysis on previously.  */
3814   my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3815                       19990913);
3816
3817   need_new_binding = 1;
3818
3819   if (DECL_TEMPLATE_PARM_P (x))
3820     /* Template parameters have no context; they are not X::T even
3821        when declared within a class or namespace.  */
3822     ;
3823   else
3824     {
3825       if (current_function_decl && x != current_function_decl
3826           /* A local declaration for a function doesn't constitute
3827              nesting.  */
3828           && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3829           /* A local declaration for an `extern' variable is in the
3830              scoped of the current namespace, not the current
3831              function.  */
3832           && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3833           && !DECL_CONTEXT (x))
3834         DECL_CONTEXT (x) = current_function_decl;
3835
3836       /* If this is the declaration for a namespace-scope function,
3837          but the declaration itself is in a local scope, mark the
3838          declaration.  */
3839       if (TREE_CODE (x) == FUNCTION_DECL
3840           && DECL_NAMESPACE_SCOPE_P (x)
3841           && current_function_decl
3842           && x != current_function_decl)
3843         DECL_LOCAL_FUNCTION_P (x) = 1;
3844     }
3845
3846   name = DECL_NAME (x);
3847   if (name)
3848     {
3849 #if 0
3850       /* Not needed...see below.  */
3851       char *file;
3852       int line;
3853 #endif
3854       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3855         name = TREE_OPERAND (name, 0);
3856
3857       /* Namespace-scoped variables are not found in the current level. */
3858       if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x))
3859         t = namespace_binding (name, DECL_CONTEXT (x));
3860       else
3861         t = lookup_name_current_level (name);
3862
3863       /* If we are declaring a function, and the result of name-lookup
3864          was an OVERLOAD, look for an overloaded instance that is
3865          actually the same as the function we are declaring.  (If
3866          there is one, we have to merge our declaration with the
3867          previous declaration.)  */
3868       if (t && TREE_CODE (t) == OVERLOAD)
3869         {
3870           tree match;
3871
3872           if (TREE_CODE (x) == FUNCTION_DECL)
3873             for (match = t; match; match = OVL_NEXT (match))
3874               {
3875                 if (DECL_ASSEMBLER_NAME (OVL_CURRENT (t))
3876                     == DECL_ASSEMBLER_NAME (x))
3877                   break;
3878               }
3879           else
3880             /* Just choose one.  */
3881             match = t;
3882
3883           if (match)
3884             t = OVL_CURRENT (match);
3885           else
3886             t = NULL_TREE;
3887         }
3888
3889       if (t == error_mark_node)
3890         {
3891           /* error_mark_node is 0 for a while during initialization!  */
3892           t = NULL_TREE;
3893           cp_error_at ("`%#D' used prior to declaration", x);
3894         }
3895       else if (t != NULL_TREE)
3896         {
3897           if (TREE_CODE (t) == PARM_DECL)
3898             {
3899               if (DECL_CONTEXT (t) == NULL_TREE)
3900                 fatal ("parse errors have confused me too much");
3901
3902               /* Check for duplicate params.  */
3903               if (duplicate_decls (x, t))
3904                 return t;
3905             }
3906           else if ((DECL_EXTERN_C_FUNCTION_P (x)
3907                     || DECL_FUNCTION_TEMPLATE_P (x))
3908                    && is_overloaded_fn (t))
3909             /* Don't do anything just yet. */;
3910           else if (t == wchar_decl_node)
3911             {
3912               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3913                 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x));
3914
3915               /* Throw away the redeclaration.  */
3916               return t;
3917             }
3918           else if (TREE_CODE (t) != TREE_CODE (x))
3919             {
3920               if (duplicate_decls (x, t))
3921                 return t;
3922             }
3923           else if (duplicate_decls (x, t))
3924             {
3925               if (TREE_CODE (t) == TYPE_DECL)
3926                 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3927               else if (TREE_CODE (t) == FUNCTION_DECL)
3928                 check_default_args (t);
3929
3930               return t;
3931             }
3932           else if (DECL_MAIN_P (x))
3933             {
3934               /* A redeclaration of main, but not a duplicate of the
3935                  previous one.
3936
3937                  [basic.start.main]
3938
3939                  This function shall not be overloaded.  */
3940               cp_error_at ("invalid redeclaration of `%D'", t);
3941               cp_error ("as `%D'", x);
3942               /* We don't try to push this declaration since that
3943                  causes a crash.  */
3944               return x;
3945             }
3946         }
3947
3948       check_template_shadow (x);
3949
3950       /* If this is a function conjured up by the backend, massage it
3951          so it looks friendly.  */
3952       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
3953         {
3954           retrofit_lang_decl (x);
3955           DECL_LANGUAGE (x) = lang_c;
3956         }
3957
3958       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
3959         {
3960           t = push_overloaded_decl (x, PUSH_LOCAL);
3961           if (t != x)
3962             return t;
3963           if (!namespace_bindings_p ())
3964             /* We do not need to create a binding for this name;
3965                push_overloaded_decl will have already done so if
3966                necessary.  */
3967             need_new_binding = 0;
3968         }
3969       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
3970         {
3971           t = push_overloaded_decl (x, PUSH_GLOBAL);
3972           if (t == x)
3973             add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
3974           return t;
3975         }
3976
3977       /* If declaring a type as a typedef, copy the type (unless we're
3978          at line 0), and install this TYPE_DECL as the new type's typedef
3979          name.  See the extensive comment in ../c-decl.c (pushdecl). */
3980       if (TREE_CODE (x) == TYPE_DECL)
3981         {
3982           tree type = TREE_TYPE (x);
3983           if (DECL_SOURCE_LINE (x) == 0)
3984             {
3985               if (TYPE_NAME (type) == 0)
3986                 TYPE_NAME (type) = x;
3987             }
3988           else if (type != error_mark_node && TYPE_NAME (type) != x
3989                    /* We don't want to copy the type when all we're
3990                       doing is making a TYPE_DECL for the purposes of
3991                       inlining.  */
3992                    && (!TYPE_NAME (type)
3993                        || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
3994             {
3995               DECL_ORIGINAL_TYPE (x) = type;
3996               type = build_type_copy (type);
3997               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
3998               TYPE_NAME (type) = x;
3999               TREE_TYPE (x) = type;
4000             }
4001
4002           if (type != error_mark_node
4003               && TYPE_NAME (type)
4004               && TYPE_IDENTIFIER (type))
4005             set_identifier_type_value_with_scope (DECL_NAME (x), type,
4006                                                   current_binding_level);
4007
4008         }
4009
4010       /* Multiple external decls of the same identifier ought to match.
4011
4012          We get warnings about inline functions where they are defined.
4013          We get warnings about other functions from push_overloaded_decl.
4014
4015          Avoid duplicate warnings where they are used.  */
4016       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
4017         {
4018           tree decl;
4019
4020           if (IDENTIFIER_NAMESPACE_VALUE (name) != NULL_TREE
4021               && IDENTIFIER_NAMESPACE_VALUE (name) != error_mark_node
4022               && (DECL_EXTERNAL (IDENTIFIER_NAMESPACE_VALUE (name))
4023                   || TREE_PUBLIC (IDENTIFIER_NAMESPACE_VALUE (name))))
4024             decl = IDENTIFIER_NAMESPACE_VALUE (name);
4025           else
4026             decl = NULL_TREE;
4027
4028           if (decl
4029               /* If different sort of thing, we already gave an error.  */
4030               && TREE_CODE (decl) == TREE_CODE (x)
4031               && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
4032             {
4033               cp_pedwarn ("type mismatch with previous external decl", x);
4034               cp_pedwarn_at ("previous external decl of `%#D'", decl);
4035             }
4036         }
4037
4038       /* This name is new in its binding level.
4039          Install the new declaration and return it.  */
4040       if (namespace_bindings_p ())
4041         {
4042           /* Install a global value.  */
4043
4044           /* If the first global decl has external linkage,
4045              warn if we later see static one.  */
4046           if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
4047             TREE_PUBLIC (name) = 1;
4048
4049           /* Bind the mangled name for the entity.  In the future, we
4050              should not need to do this; mangled names are an
4051              implementation detail of which the front-end should not
4052              need to be aware.  */
4053           if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
4054                 && t != NULL_TREE)
4055               /* For an ordinary function, we create a binding from
4056                  the mangled name (i.e., NAME) to the DECL.  But, for
4057                  an `extern "C"' function, the mangled name and the
4058                  ordinary name are the same so we need not do this.  */
4059               && !DECL_EXTERN_C_FUNCTION_P (x))
4060             {
4061               tree mangled_name;
4062
4063               if (TREE_CODE (x) == TYPE_DECL || TREE_CODE (x) == VAR_DECL
4064                   || TREE_CODE (x) == NAMESPACE_DECL)
4065                 mangled_name = name;
4066               else
4067                 mangled_name = DECL_ASSEMBLER_NAME (x);
4068
4069               if (TREE_CODE (x) == FUNCTION_DECL)
4070                 my_friendly_assert
4071                   ((IDENTIFIER_GLOBAL_VALUE (mangled_name) == NULL_TREE)
4072                   || (IDENTIFIER_GLOBAL_VALUE (mangled_name) == x), 378);
4073               SET_IDENTIFIER_NAMESPACE_VALUE (mangled_name, x);
4074             }
4075
4076           /* Don't forget if the function was used via an implicit decl.  */
4077           if (IDENTIFIER_IMPLICIT_DECL (name)
4078               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
4079             TREE_USED (x) = 1;
4080
4081           /* Don't forget if its address was taken in that way.  */
4082           if (IDENTIFIER_IMPLICIT_DECL (name)
4083               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
4084             TREE_ADDRESSABLE (x) = 1;
4085
4086           /* Warn about mismatches against previous implicit decl.  */
4087           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
4088               /* If this real decl matches the implicit, don't complain.  */
4089               && ! (TREE_CODE (x) == FUNCTION_DECL
4090                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
4091             cp_warning
4092               ("`%D' was previously implicitly declared to return `int'", x);
4093
4094           /* If new decl is `static' and an `extern' was seen previously,
4095              warn about it.  */
4096           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
4097             warn_extern_redeclared_static (x, t);
4098         }
4099       else
4100         {
4101           /* Here to install a non-global value.  */
4102           tree oldlocal = IDENTIFIER_VALUE (name);
4103           tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
4104
4105           if (need_new_binding)
4106             {
4107               push_local_binding (name, x, 0);
4108               /* Because push_local_binding will hook X on to the
4109                  current_binding_level's name list, we don't want to
4110                  do that again below.  */
4111               need_new_binding = 0;
4112             }
4113
4114           /* If this is a TYPE_DECL, push it into the type value slot.  */
4115           if (TREE_CODE (x) == TYPE_DECL)
4116             set_identifier_type_value_with_scope (name, TREE_TYPE (x),
4117                                                   current_binding_level);
4118
4119           /* Clear out any TYPE_DECL shadowed by a namespace so that
4120              we won't think this is a type.  The C struct hack doesn't
4121              go through namespaces.  */
4122           if (TREE_CODE (x) == NAMESPACE_DECL)
4123             set_identifier_type_value_with_scope (name, NULL_TREE,
4124                                                   current_binding_level);
4125
4126           if (oldlocal)
4127             {
4128               tree d = oldlocal;
4129
4130               while (oldlocal
4131                      && TREE_CODE (oldlocal) == VAR_DECL
4132                      && DECL_DEAD_FOR_LOCAL (oldlocal))
4133                 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
4134
4135               if (oldlocal == NULL_TREE)
4136                 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
4137             }
4138
4139           /* If this is an extern function declaration, see if we
4140              have a global definition or declaration for the function.  */
4141           if (oldlocal == NULL_TREE
4142               && DECL_EXTERNAL (x)
4143               && oldglobal != NULL_TREE
4144               && TREE_CODE (x) == FUNCTION_DECL
4145               && TREE_CODE (oldglobal) == FUNCTION_DECL)
4146             {
4147               /* We have one.  Their types must agree.  */
4148               if (decls_match (x, oldglobal))
4149                 /* OK */;
4150               else
4151                 {
4152                   cp_warning ("extern declaration of `%#D' doesn't match", x);
4153                   cp_warning_at ("global declaration `%#D'", oldglobal);
4154                 }
4155             }
4156           /* If we have a local external declaration,
4157              and no file-scope declaration has yet been seen,
4158              then if we later have a file-scope decl it must not be static.  */
4159           if (oldlocal == NULL_TREE
4160               && oldglobal == NULL_TREE
4161               && DECL_EXTERNAL (x)
4162               && TREE_PUBLIC (x))
4163             TREE_PUBLIC (name) = 1;
4164
4165           /* Warn if shadowing an argument at the top level of the body.  */
4166           if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
4167               /* Inline decls shadow nothing.  */
4168               && !DECL_FROM_INLINE (x)
4169               && TREE_CODE (oldlocal) == PARM_DECL
4170               /* Don't complain if it's from an enclosing function.  */
4171               && DECL_CONTEXT (oldlocal) == current_function_decl
4172               && TREE_CODE (x) != PARM_DECL)
4173             {
4174               /* Go to where the parms should be and see if we
4175                  find them there.  */
4176               struct binding_level *b = current_binding_level->level_chain;
4177
4178               if (cleanup_label)
4179                 b = b->level_chain;
4180
4181               /* ARM $8.3 */
4182               if (b->parm_flag == 1)
4183                 cp_error ("declaration of `%#D' shadows a parameter", name);
4184             }
4185
4186           /* Maybe warn if shadowing something else.  */
4187           if (warn_shadow && !DECL_EXTERNAL (x)
4188               /* Inline decls shadow nothing.  */
4189               && !DECL_FROM_INLINE (x)
4190               /* No shadow warnings for internally generated vars.  */
4191               && ! DECL_ARTIFICIAL (x)
4192               /* No shadow warnings for vars made for inlining.  */
4193               && ! DECL_FROM_INLINE (x))
4194             {
4195               if (oldlocal != NULL_TREE && TREE_CODE (oldlocal) == PARM_DECL)
4196                 warning ("declaration of `%s' shadows a parameter",
4197                         IDENTIFIER_POINTER (name));
4198               else if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4199                        && current_class_ptr
4200                        && !TREE_STATIC (name))
4201                 warning ("declaration of `%s' shadows a member of `this'",
4202                         IDENTIFIER_POINTER (name));
4203               else if (oldlocal != NULL_TREE)
4204                 warning ("declaration of `%s' shadows previous local",
4205                         IDENTIFIER_POINTER (name));
4206               else if (oldglobal != NULL_TREE)
4207                 /* XXX shadow warnings in outer-more namespaces */
4208                 warning ("declaration of `%s' shadows global declaration",
4209                         IDENTIFIER_POINTER (name));
4210             }
4211         }
4212
4213       if (TREE_CODE (x) == FUNCTION_DECL)
4214         check_default_args (x);
4215
4216       /* Keep count of variables in this level with incomplete type.  */
4217       if (TREE_CODE (x) == VAR_DECL
4218           && TREE_TYPE (x) != error_mark_node
4219           && ((!COMPLETE_TYPE_P (TREE_TYPE (x))
4220                && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
4221               /* RTTI TD entries are created while defining the type_info.  */
4222               || (TYPE_LANG_SPECIFIC (TREE_TYPE (x))
4223                   && TYPE_BEING_DEFINED (TREE_TYPE (x)))))
4224         {
4225           if (namespace_bindings_p ())
4226             namespace_scope_incomplete
4227               = tree_cons (NULL_TREE, x, namespace_scope_incomplete);
4228           else
4229             current_binding_level->incomplete
4230               = tree_cons (NULL_TREE, x, current_binding_level->incomplete);
4231         }
4232     }
4233
4234   if (need_new_binding)
4235     add_decl_to_level (x,
4236                        DECL_NAMESPACE_SCOPE_P (x)
4237                        ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4238                        : current_binding_level);
4239
4240   return x;
4241 }
4242
4243 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
4244    caller to set DECL_CONTEXT properly.  */
4245
4246 static tree
4247 pushdecl_with_scope (x, level)
4248      tree x;
4249      struct binding_level *level;
4250 {
4251   register struct binding_level *b;
4252   tree function_decl = current_function_decl;
4253
4254   current_function_decl = NULL_TREE;
4255   if (level->parm_flag == 2)
4256     {
4257       b = class_binding_level;
4258       class_binding_level = level;
4259       pushdecl_class_level (x);
4260       class_binding_level = b;
4261     }
4262   else
4263     {
4264       b = current_binding_level;
4265       current_binding_level = level;
4266       x = pushdecl (x);
4267       current_binding_level = b;
4268     }
4269   current_function_decl = function_decl;
4270   return x;
4271 }
4272
4273 /* Like pushdecl, only it places X in the current namespace,
4274    if appropriate.  */
4275
4276 tree
4277 pushdecl_namespace_level (x)
4278      tree x;
4279 {
4280   register struct binding_level *b = current_binding_level;
4281   register tree t;
4282
4283   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4284
4285   /* Now, the type_shadowed stack may screw us.  Munge it so it does
4286      what we want.  */
4287   if (TREE_CODE (x) == TYPE_DECL)
4288     {
4289       tree name = DECL_NAME (x);
4290       tree newval;
4291       tree *ptr = (tree *)0;
4292       for (; b != global_binding_level; b = b->level_chain)
4293         {
4294           tree shadowed = b->type_shadowed;
4295           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4296             if (TREE_PURPOSE (shadowed) == name)
4297               {
4298                 ptr = &TREE_VALUE (shadowed);
4299                 /* Can't break out of the loop here because sometimes
4300                    a binding level will have duplicate bindings for
4301                    PT names.  It's gross, but I haven't time to fix it.  */
4302               }
4303         }
4304       newval = TREE_TYPE (x);
4305       if (ptr == (tree *)0)
4306         {
4307           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
4308              up here if this is changed to an assertion.  --KR  */
4309           SET_IDENTIFIER_TYPE_VALUE (name, newval);
4310         }
4311       else
4312         {
4313           *ptr = newval;
4314         }
4315     }
4316   return t;
4317 }
4318
4319 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4320    if appropriate.  */
4321
4322 tree
4323 pushdecl_top_level (x)
4324      tree x;
4325 {
4326   push_to_top_level ();
4327   x = pushdecl_namespace_level (x);
4328   pop_from_top_level ();
4329   return x;
4330 }
4331
4332 /* Make the declaration of X appear in CLASS scope.  */
4333
4334 void
4335 pushdecl_class_level (x)
4336      tree x;
4337 {
4338   /* Don't use DECL_ASSEMBLER_NAME here!  Everything that looks in class
4339      scope looks for the pre-mangled name.  */
4340   register tree name;
4341
4342   if (TREE_CODE (x) == OVERLOAD)
4343     x = OVL_CURRENT (x);
4344   name = DECL_NAME (x);
4345
4346   if (name)
4347     {
4348       push_class_level_binding (name, x);
4349       if (TREE_CODE (x) == TYPE_DECL)
4350         set_identifier_type_value (name, TREE_TYPE (x));
4351     }
4352   else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4353     {
4354       tree f;
4355
4356       for (f = TYPE_FIELDS (TREE_TYPE (x));
4357            f;
4358            f = TREE_CHAIN (f))
4359         pushdecl_class_level (f);
4360     }
4361 }
4362
4363 /* Enter DECL into the symbol table, if that's appropriate.  Returns
4364    DECL, or a modified version thereof.  */
4365
4366 tree
4367 maybe_push_decl (decl)
4368      tree decl;
4369 {
4370   tree type = TREE_TYPE (decl);
4371
4372   /* Add this decl to the current binding level, but not if it comes
4373      from another scope, e.g. a static member variable.  TEM may equal
4374      DECL or it may be a previous decl of the same name.  */
4375   if (decl == error_mark_node
4376       || (TREE_CODE (decl) != PARM_DECL
4377           && DECL_CONTEXT (decl) != NULL_TREE
4378           /* Definitions of namespace members outside their namespace are
4379              possible. */
4380           && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4381       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4382       || TREE_CODE (type) == UNKNOWN_TYPE
4383       /* The declaration of a template specialization does not affect
4384          the functions available for overload resolution, so we do not
4385          call pushdecl.  */
4386       || (TREE_CODE (decl) == FUNCTION_DECL
4387           && DECL_TEMPLATE_SPECIALIZATION (decl)))
4388     return decl;
4389   else
4390     return pushdecl (decl);
4391 }
4392
4393 /* Make the declaration(s) of X appear in CLASS scope
4394    under the name NAME.  */
4395
4396 void
4397 push_class_level_binding (name, x)
4398      tree name;
4399      tree x;
4400 {
4401   tree binding;
4402   /* The class_binding_level will be NULL if x is a template
4403      parameter name in a member template.  */
4404   if (!class_binding_level)
4405     return;
4406
4407   /* Make sure that this new member does not have the same name
4408      as a template parameter.  */
4409   if (TYPE_BEING_DEFINED (current_class_type))
4410     check_template_shadow (x);
4411
4412   /* If this declaration shadows a declaration from an enclosing
4413      class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4414      we leave this class.  Record the shadowed declaration here.  */
4415   binding = IDENTIFIER_BINDING (name);
4416   if (binding
4417       && ((TREE_CODE (x) == OVERLOAD
4418            && BINDING_VALUE (binding)
4419            && is_overloaded_fn (BINDING_VALUE (binding)))
4420           || INHERITED_VALUE_BINDING_P (binding)))
4421     {
4422       tree shadow;
4423       tree old_decl;
4424
4425       /* If the old binding was from a base class, and was for a tag
4426          name, slide it over to make room for the new binding.  The
4427          old binding is still visible if explicitly qualified with a
4428          class-key.  */
4429       if (INHERITED_VALUE_BINDING_P (binding)
4430           && BINDING_VALUE (binding)
4431           && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4432           && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4433           && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4434         {
4435           old_decl = BINDING_TYPE (binding);
4436           BINDING_TYPE (binding) = BINDING_VALUE (binding);
4437           BINDING_VALUE (binding) = NULL_TREE;
4438           INHERITED_VALUE_BINDING_P (binding) = 0;
4439         }
4440       else
4441         old_decl = BINDING_VALUE (binding);
4442
4443       /* There was already a binding for X containing fewer
4444          functions than are named in X.  Find the previous
4445          declaration of X on the class-shadowed list, and update it.  */
4446       for (shadow = class_binding_level->class_shadowed;
4447            shadow;
4448            shadow = TREE_CHAIN (shadow))
4449         if (TREE_PURPOSE (shadow) == name
4450             && TREE_TYPE (shadow) == old_decl)
4451           {
4452             BINDING_VALUE (binding) = x;
4453             INHERITED_VALUE_BINDING_P (binding) = 0;
4454             TREE_TYPE (shadow) = x;
4455             return;
4456           }
4457     }
4458
4459   /* If we didn't replace an existing binding, put the binding on the
4460      stack of bindings for the identifier, and update
4461      IDENTIFIER_CLASS_VALUE.  */
4462   if (push_class_binding (name, x))
4463     {
4464       class_binding_level->class_shadowed
4465         = tree_cons (name, IDENTIFIER_CLASS_VALUE (name),
4466                      class_binding_level->class_shadowed);
4467       /* Record the value we are binding NAME to so that we can know
4468          what to pop later.  */
4469       TREE_TYPE (class_binding_level->class_shadowed) = x;
4470     }
4471 }
4472
4473 /* Insert another USING_DECL into the current binding level, returning
4474    this declaration. If this is a redeclaration, do nothing, and
4475    return NULL_TREE if this not in namespace scope (in namespace
4476    scope, a using decl might extend any previous bindings).  */
4477
4478 tree
4479 push_using_decl (scope, name)
4480      tree scope;
4481      tree name;
4482 {
4483   tree decl;
4484
4485   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4486   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4487   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4488     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4489       break;
4490   if (decl)
4491     return namespace_bindings_p () ? decl : NULL_TREE;
4492   decl = build_lang_decl (USING_DECL, name, void_type_node);
4493   DECL_INITIAL (decl) = scope;
4494   TREE_CHAIN (decl) = current_binding_level->usings;
4495   current_binding_level->usings = decl;
4496   return decl;
4497 }
4498
4499 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4500    changed (i.e. there was already a directive), or the fresh
4501    TREE_LIST otherwise.  */
4502
4503 tree
4504 push_using_directive (used)
4505      tree used;
4506 {
4507   tree ud = current_binding_level->using_directives;
4508   tree iter, ancestor;
4509
4510   /* Check if we already have this. */
4511   if (purpose_member (used, ud) != NULL_TREE)
4512     return NULL_TREE;
4513
4514   /* Recursively add all namespaces used. */
4515   for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4516     push_using_directive (TREE_PURPOSE (iter));
4517
4518   ancestor = namespace_ancestor (current_decl_namespace (), used);
4519   ud = current_binding_level->using_directives;
4520   ud = tree_cons (used, ancestor, ud);
4521   current_binding_level->using_directives = ud;
4522   return ud;
4523 }
4524
4525 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4526    other definitions already in place.  We get around this by making
4527    the value of the identifier point to a list of all the things that
4528    want to be referenced by that name.  It is then up to the users of
4529    that name to decide what to do with that list.
4530
4531    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
4532    DECL_TEMPLATE_RESULT.  It is dealt with the same way.
4533
4534    FLAGS is a bitwise-or of the following values:
4535      PUSH_LOCAL: Bind DECL in the current scope, rather than at
4536                  namespace scope.
4537      PUSH_USING: DECL is being pushed as the result of a using
4538                  declaration.
4539
4540    The value returned may be a previous declaration if we guessed wrong
4541    about what language DECL should belong to (C or C++).  Otherwise,
4542    it's always DECL (and never something that's not a _DECL).  */
4543
4544 tree
4545 push_overloaded_decl (decl, flags)
4546      tree decl;
4547      int flags;
4548 {
4549   tree name = DECL_NAME (decl);
4550   tree old;
4551   tree new_binding;
4552   int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4553
4554   if (doing_global)
4555     old = namespace_binding (name, DECL_CONTEXT (decl));
4556   else
4557     old = lookup_name_current_level (name);
4558
4559   if (old)
4560     {
4561       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4562         {
4563           tree t = TREE_TYPE (old);
4564           if (IS_AGGR_TYPE (t) && warn_shadow
4565               && (! DECL_IN_SYSTEM_HEADER (decl)
4566                   || ! DECL_IN_SYSTEM_HEADER (old)))
4567             cp_warning ("`%#D' hides constructor for `%#T'", decl, t);
4568           old = NULL_TREE;
4569         }
4570       else if (is_overloaded_fn (old))
4571         {
4572           tree tmp;
4573
4574           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4575             {
4576               tree fn = OVL_CURRENT (tmp);
4577
4578               if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4579                   && !(flags & PUSH_USING)
4580                   && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4581                                 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4582                 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4583                           decl, fn);
4584
4585               if (duplicate_decls (decl, fn))
4586                 return fn;
4587             }
4588         }
4589       else if (old == error_mark_node)
4590         /* Ignore the undefined symbol marker.  */
4591         old = NULL_TREE;
4592       else
4593         {
4594           cp_error_at ("previous non-function declaration `%#D'", old);
4595           cp_error ("conflicts with function declaration `%#D'", decl);
4596           return decl;
4597         }
4598     }
4599
4600   if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4601     {
4602       if (old && TREE_CODE (old) != OVERLOAD)
4603         new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4604       else
4605         new_binding = ovl_cons (decl, old);
4606       if (flags & PUSH_USING)
4607         OVL_USED (new_binding) = 1;
4608     }
4609   else
4610     /* NAME is not ambiguous.  */
4611     new_binding = decl;
4612
4613   if (doing_global)
4614     set_namespace_binding (name, current_namespace, new_binding);
4615   else
4616     {
4617       /* We only create an OVERLOAD if there was a previous binding at
4618          this level, or if decl is a template. In the former case, we
4619          need to remove the old binding and replace it with the new
4620          binding.  We must also run through the NAMES on the binding
4621          level where the name was bound to update the chain.  */
4622
4623       if (TREE_CODE (new_binding) == OVERLOAD && old)
4624         {
4625           tree *d;
4626
4627           for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4628                *d;
4629                d = &TREE_CHAIN (*d))
4630             if (*d == old
4631                 || (TREE_CODE (*d) == TREE_LIST
4632                     && TREE_VALUE (*d) == old))
4633               {
4634                 if (TREE_CODE (*d) == TREE_LIST)
4635                   /* Just replace the old binding with the new.  */
4636                   TREE_VALUE (*d) = new_binding;
4637                 else
4638                   /* Build a TREE_LIST to wrap the OVERLOAD.  */
4639                   *d = tree_cons (NULL_TREE, new_binding,
4640                                   TREE_CHAIN (*d));
4641
4642                 /* And update the CPLUS_BINDING node.  */
4643                 BINDING_VALUE (IDENTIFIER_BINDING (name))
4644                   = new_binding;
4645                 return decl;
4646               }
4647
4648           /* We should always find a previous binding in this case.  */
4649           my_friendly_abort (0);
4650         }
4651
4652       /* Install the new binding.  */
4653       push_local_binding (name, new_binding, flags);
4654     }
4655
4656   return decl;
4657 }
4658 \f
4659 /* Generate an implicit declaration for identifier FUNCTIONID
4660    as a function of type int ().  Print a warning if appropriate.  */
4661
4662 tree
4663 implicitly_declare (functionid)
4664      tree functionid;
4665 {
4666   register tree decl;
4667
4668   /* We used to reuse an old implicit decl here,
4669      but this loses with inline functions because it can clobber
4670      the saved decl chains.  */
4671   decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4672
4673   DECL_EXTERNAL (decl) = 1;
4674   TREE_PUBLIC (decl) = 1;
4675
4676   /* ISO standard says implicit declarations are in the innermost block.
4677      So we record the decl in the standard fashion.  */
4678   pushdecl (decl);
4679   rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
4680
4681   if (warn_implicit
4682       /* Only one warning per identifier.  */
4683       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4684     {
4685       cp_pedwarn ("implicit declaration of function `%#D'", decl);
4686     }
4687
4688   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4689
4690   return decl;
4691 }
4692
4693 /* Return zero if the declaration NEWDECL is valid
4694    when the declaration OLDDECL (assumed to be for the same name)
4695    has already been seen.
4696    Otherwise return an error message format string with a %s
4697    where the identifier should go.  */
4698
4699 static const char *
4700 redeclaration_error_message (newdecl, olddecl)
4701      tree newdecl, olddecl;
4702 {
4703   if (TREE_CODE (newdecl) == TYPE_DECL)
4704     {
4705       /* Because C++ can put things into name space for free,
4706          constructs like "typedef struct foo { ... } foo"
4707          would look like an erroneous redeclaration.  */
4708       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4709         return 0;
4710       else
4711         return "redefinition of `%#D'";
4712     }
4713   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4714     {
4715       /* If this is a pure function, its olddecl will actually be
4716          the original initialization to `0' (which we force to call
4717          abort()).  Don't complain about redefinition in this case.  */
4718       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4719         return 0;
4720
4721       /* If both functions come from different namespaces, this is not
4722          a redeclaration - this is a conflict with a used function. */
4723       if (DECL_NAMESPACE_SCOPE_P (olddecl)
4724           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4725         return "`%D' conflicts with used function";
4726
4727       /* We'll complain about linkage mismatches in
4728          warn_extern_redeclared_static.  */
4729
4730       /* Defining the same name twice is no good.  */
4731       if (DECL_INITIAL (olddecl) != NULL_TREE
4732           && DECL_INITIAL (newdecl) != NULL_TREE)
4733         {
4734           if (DECL_NAME (olddecl) == NULL_TREE)
4735             return "`%#D' not declared in class";
4736           else
4737             return "redefinition of `%#D'";
4738         }
4739       return 0;
4740     }
4741   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4742     {
4743       if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4744            && (DECL_TEMPLATE_RESULT (newdecl)
4745                != DECL_TEMPLATE_RESULT (olddecl))
4746            && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4747            && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4748           || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4749               && COMPLETE_TYPE_P (TREE_TYPE (newdecl))
4750               && COMPLETE_TYPE_P (TREE_TYPE (olddecl))))
4751         return "redefinition of `%#D'";
4752       return 0;
4753     }
4754   else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
4755     {
4756       /* Objects declared at top level:  */
4757       /* If at least one is a reference, it's ok.  */
4758       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4759         return 0;
4760       /* Reject two definitions.  */
4761       return "redefinition of `%#D'";
4762     }
4763   else
4764     {
4765       /* Objects declared with block scope:  */
4766       /* Reject two definitions, and reject a definition
4767          together with an external reference.  */
4768       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4769         return "redeclaration of `%#D'";
4770       return 0;
4771     }
4772 }
4773 \f
4774 /* Create a new label, named ID.  */
4775
4776 static tree
4777 make_label_decl (id, local_p)
4778      tree id;
4779      int local_p;
4780 {
4781   tree decl;
4782
4783   decl = build_decl (LABEL_DECL, id, void_type_node);
4784   if (expanding_p)
4785     /* Make sure every label has an rtx.  */
4786     label_rtx (decl);
4787
4788   DECL_CONTEXT (decl) = current_function_decl;
4789   DECL_MODE (decl) = VOIDmode;
4790   C_DECLARED_LABEL_FLAG (decl) = local_p;
4791
4792   /* Say where one reference is to the label, for the sake of the
4793      error if it is not defined.  */
4794   DECL_SOURCE_LINE (decl) = lineno;
4795   DECL_SOURCE_FILE (decl) = input_filename;
4796
4797   /* Record the fact that this identifier is bound to this label.  */
4798   SET_IDENTIFIER_LABEL_VALUE (id, decl);
4799
4800   return decl;
4801 }
4802
4803 /* Record this label on the list of used labels so that we can check
4804    at the end of the function to see whether or not the label was
4805    actually defined, and so we can check when the label is defined whether
4806    this use is valid.  */
4807
4808 static void
4809 use_label (decl)
4810      tree decl;
4811 {
4812   if (named_label_uses == NULL
4813       || named_label_uses->names_in_scope != current_binding_level->names
4814       || named_label_uses->label_decl != decl)
4815     {
4816       struct named_label_use_list *new_ent;
4817       new_ent = ((struct named_label_use_list *)
4818                  ggc_alloc (sizeof (struct named_label_use_list)));
4819       new_ent->label_decl = decl;
4820       new_ent->names_in_scope = current_binding_level->names;
4821       new_ent->binding_level = current_binding_level;
4822       new_ent->lineno_o_goto = lineno;
4823       new_ent->filename_o_goto = input_filename;
4824       new_ent->next = named_label_uses;
4825       named_label_uses = new_ent;
4826     }
4827 }
4828
4829 /* Look for a label named ID in the current function.  If one cannot
4830    be found, create one.  (We keep track of used, but undefined,
4831    labels, and complain about them at the end of a function.)  */
4832
4833 tree
4834 lookup_label (id)
4835      tree id;
4836 {
4837   tree decl;
4838   struct named_label_list *ent;
4839
4840   /* You can't use labels at global scope.  */
4841   if (current_function_decl == NULL_TREE)
4842     {
4843       error ("label `%s' referenced outside of any function",
4844              IDENTIFIER_POINTER (id));
4845       return NULL_TREE;
4846     }
4847
4848   /* See if we've already got this label.  */
4849   decl = IDENTIFIER_LABEL_VALUE (id);
4850   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4851     return decl;
4852
4853   /* Record this label on the list of labels used in this function.
4854      We do this before calling make_label_decl so that we get the
4855      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
4856   ent = ((struct named_label_list *)
4857          ggc_alloc_cleared (sizeof (struct named_label_list)));
4858   ent->old_value = IDENTIFIER_LABEL_VALUE (id);
4859   ent->next = named_labels;
4860   named_labels = ent;
4861
4862   /* We need a new label.  */
4863   decl = make_label_decl (id, /*local_p=*/0);
4864
4865   /* Now fill in the information we didn't have before.  */
4866   ent->label_decl = decl;
4867
4868   return decl;
4869 }
4870
4871 /* Declare a local label named ID.  */
4872
4873 tree
4874 declare_local_label (id)
4875      tree id;
4876 {
4877   tree decl;
4878
4879   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4880      this scope we can restore the old value of
4881      IDENTIFIER_TYPE_VALUE.  */
4882   current_binding_level->shadowed_labels
4883     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4884                  current_binding_level->shadowed_labels);
4885   /* Look for the label.  */
4886   decl = make_label_decl (id, /*local_p=*/1);
4887   /* Now fill in the information we didn't have before.  */
4888   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4889
4890   return decl;
4891 }
4892
4893 /* Returns nonzero if it is ill-formed to jump past the declaration of
4894    DECL.  Returns 2 if it's also a real problem.  */
4895
4896 static int
4897 decl_jump_unsafe (decl)
4898      tree decl;
4899 {
4900   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
4901     return 0;
4902
4903   if (DECL_INITIAL (decl) == NULL_TREE
4904       && pod_type_p (TREE_TYPE (decl)))
4905     return 0;
4906
4907   /* This is really only important if we're crossing an initialization.
4908      The POD stuff is just pedantry; why should it matter if the class
4909      contains a field of pointer to member type?  */
4910   if (DECL_INITIAL (decl)
4911       || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
4912     return 2;
4913   return 1;
4914 }
4915
4916 /* Check that a single previously seen jump to a newly defined label
4917    is OK.  DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
4918    the jump context; NAMES are the names in scope in LEVEL at the jump
4919    context; FILE and LINE are the source position of the jump or 0.  */
4920
4921 static void
4922 check_previous_goto_1 (decl, level, names, file, line)
4923      tree decl;
4924      struct binding_level *level;
4925      tree names;
4926      const char *file;
4927      int line;
4928 {
4929   int identified = 0;
4930   int saw_eh = 0;
4931   struct binding_level *b = current_binding_level;
4932   for (; b; b = b->level_chain)
4933     {
4934       tree new_decls = b->names;
4935       tree old_decls = (b == level ? names : NULL_TREE);
4936       for (; new_decls != old_decls;
4937            new_decls = TREE_CHAIN (new_decls))
4938         {
4939           int problem = decl_jump_unsafe (new_decls);
4940           if (! problem)
4941             continue;
4942
4943           if (! identified)
4944             {
4945               if (decl)
4946                 cp_pedwarn ("jump to label `%D'", decl);
4947               else
4948                 pedwarn ("jump to case label");
4949
4950               if (file)
4951                 pedwarn_with_file_and_line (file, line, "  from here");
4952               identified = 1;
4953             }
4954
4955           if (problem > 1 && DECL_ARTIFICIAL (new_decls))
4956             /* Can't skip init of __exception_info.  */
4957             cp_error_at ("  enters catch block", new_decls);
4958           else if (problem > 1)
4959             cp_error_at ("  crosses initialization of `%#D'",
4960                          new_decls);
4961           else
4962             cp_pedwarn_at ("  enters scope of non-POD `%#D'",
4963                            new_decls);
4964         }
4965
4966       if (b == level)
4967         break;
4968       if (b->eh_region && ! saw_eh)
4969         {
4970           if (! identified)
4971             {
4972               if (decl)
4973                 cp_pedwarn ("jump to label `%D'", decl);
4974               else
4975                 pedwarn ("jump to case label");
4976
4977               if (file)
4978                 pedwarn_with_file_and_line (file, line, "  from here");
4979               identified = 1;
4980             }
4981           error ("  enters try block");
4982           saw_eh = 1;
4983         }
4984     }
4985 }
4986
4987 static void
4988 check_previous_goto (use)
4989      struct named_label_use_list *use;
4990 {
4991   check_previous_goto_1 (use->label_decl, use->binding_level,
4992                          use->names_in_scope, use->filename_o_goto,
4993                          use->lineno_o_goto);
4994 }
4995
4996 static void
4997 check_switch_goto (level)
4998      struct binding_level *level;
4999 {
5000   check_previous_goto_1 (NULL_TREE, level, level->names, NULL, 0);
5001 }
5002
5003 /* Check that any previously seen jumps to a newly defined label DECL
5004    are OK.  Called by define_label.  */
5005
5006 static void
5007 check_previous_gotos (decl)
5008      tree decl;
5009 {
5010   struct named_label_use_list **usep;
5011
5012   if (! TREE_USED (decl))
5013     return;
5014
5015   for (usep = &named_label_uses; *usep; )
5016     {
5017       struct named_label_use_list *use = *usep;
5018       if (use->label_decl == decl)
5019         {
5020           check_previous_goto (use);
5021           *usep = use->next;
5022         }
5023       else
5024         usep = &(use->next);
5025     }
5026 }
5027
5028 /* Check that a new jump to a label DECL is OK.  Called by
5029    finish_goto_stmt.  */
5030
5031 void
5032 check_goto (decl)
5033      tree decl;
5034 {
5035   int identified = 0;
5036   tree bad;
5037   struct named_label_list *lab;
5038
5039   /* We can't know where a computed goto is jumping.  So we assume
5040      that it's OK.  */
5041   if (! DECL_P (decl))
5042     return;
5043
5044   /* If the label hasn't been defined yet, defer checking.  */
5045   if (! DECL_INITIAL (decl))
5046     {
5047       use_label (decl);
5048       return;
5049     }
5050
5051   for (lab = named_labels; lab; lab = lab->next)
5052     if (decl == lab->label_decl)
5053       break;
5054
5055   /* If the label is not on named_labels it's a gcc local label, so
5056      it must be in an outer scope, so jumping to it is always OK.  */
5057   if (lab == 0)
5058     return;
5059
5060   if ((lab->eh_region || lab->bad_decls) && !identified)
5061     {
5062       cp_pedwarn_at ("jump to label `%D'", decl);
5063       pedwarn ("  from here");
5064       identified = 1;
5065     }
5066
5067   for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad))
5068     {
5069       tree b = TREE_VALUE (bad);
5070       int u = decl_jump_unsafe (b);
5071
5072       if (u > 1 && DECL_ARTIFICIAL (b))
5073         /* Can't skip init of __exception_info.  */
5074         cp_error_at ("  enters catch block", b);
5075       else if (u > 1)
5076         cp_error_at ("  skips initialization of `%#D'", b);
5077       else
5078         cp_pedwarn_at ("  enters scope of non-POD `%#D'", b);
5079     }
5080
5081   if (lab->eh_region)
5082     error ("  enters try block");
5083 }
5084
5085 /* Define a label, specifying the location in the source file.
5086    Return the LABEL_DECL node for the label, if the definition is valid.
5087    Otherwise return 0.  */
5088
5089 tree
5090 define_label (filename, line, name)
5091      const char *filename;
5092      int line;
5093      tree name;
5094 {
5095   tree decl = lookup_label (name);
5096   struct named_label_list *ent;
5097
5098   for (ent = named_labels; ent; ent = ent->next)
5099     if (ent->label_decl == decl)
5100       break;
5101
5102   /* After labels, make any new cleanups go into their
5103      own new (temporary) binding contour.  */
5104   current_binding_level->more_cleanups_ok = 0;
5105
5106   if (name == get_identifier ("wchar_t"))
5107     cp_pedwarn ("label named wchar_t");
5108
5109   if (DECL_INITIAL (decl) != NULL_TREE)
5110     {
5111       cp_error ("duplicate label `%D'", decl);
5112       return 0;
5113     }
5114   else
5115     {
5116       /* Mark label as having been defined.  */
5117       DECL_INITIAL (decl) = error_mark_node;
5118       /* Say where in the source.  */
5119       DECL_SOURCE_FILE (decl) = filename;
5120       DECL_SOURCE_LINE (decl) = line;
5121       if (ent)
5122         {
5123           ent->names_in_scope = current_binding_level->names;
5124           ent->binding_level = current_binding_level;
5125         }
5126       check_previous_gotos (decl);
5127       current_function_return_value = NULL_TREE;
5128       return decl;
5129     }
5130 }
5131
5132 struct cp_switch
5133 {
5134   struct binding_level *level;
5135   struct cp_switch *next;
5136 };
5137
5138 static struct cp_switch *switch_stack;
5139
5140 void
5141 push_switch ()
5142 {
5143   struct cp_switch *p
5144     = (struct cp_switch *) xmalloc (sizeof (struct cp_switch));
5145   p->level = current_binding_level;
5146   p->next = switch_stack;
5147   switch_stack = p;
5148 }
5149
5150 void
5151 pop_switch ()
5152 {
5153   struct cp_switch *cs;
5154
5155   cs = switch_stack;
5156   switch_stack = switch_stack->next;
5157   free (cs);
5158 }
5159
5160 /* Note that we've seen a definition of a case label, and complain if this
5161    is a bad place for one.  */
5162
5163 void
5164 define_case_label ()
5165 {
5166   tree cleanup = last_cleanup_this_contour ();
5167
5168   if (! switch_stack)
5169     /* Don't crash; we'll complain in do_case.  */
5170     return;
5171
5172   if (cleanup)
5173     {
5174       static int explained = 0;
5175       cp_warning_at ("destructor needed for `%#D'", TREE_PURPOSE (cleanup));
5176       warning ("where case label appears here");
5177       if (!explained)
5178         {
5179           warning ("(enclose actions of previous case statements requiring");
5180           warning ("destructors in their own binding contours.)");
5181           explained = 1;
5182         }
5183     }
5184
5185   check_switch_goto (switch_stack->level);
5186
5187   /* After labels, make any new cleanups go into their
5188      own new (temporary) binding contour.  */
5189
5190   current_binding_level->more_cleanups_ok = 0;
5191   current_function_return_value = NULL_TREE;
5192 }
5193 \f
5194 /* Return the list of declarations of the current level.
5195    Note that this list is in reverse order unless/until
5196    you nreverse it; and when you do nreverse it, you must
5197    store the result back using `storedecls' or you will lose.  */
5198
5199 tree
5200 getdecls ()
5201 {
5202   return current_binding_level->names;
5203 }
5204
5205 /* Return the list of type-tags (for structs, etc) of the current level.  */
5206
5207 tree
5208 gettags ()
5209 {
5210   return current_binding_level->tags;
5211 }
5212
5213 /* Store the list of declarations of the current level.
5214    This is done for the parameter declarations of a function being defined,
5215    after they are modified in the light of any missing parameters.  */
5216
5217 static void
5218 storedecls (decls)
5219      tree decls;
5220 {
5221   current_binding_level->names = decls;
5222 }
5223
5224 /* Similarly, store the list of tags of the current level.  */
5225
5226 void
5227 storetags (tags)
5228      tree tags;
5229 {
5230   current_binding_level->tags = tags;
5231 }
5232 \f
5233 /* Given NAME, an IDENTIFIER_NODE,
5234    return the structure (or union or enum) definition for that name.
5235    Searches binding levels from BINDING_LEVEL up to the global level.
5236    If THISLEVEL_ONLY is nonzero, searches only the specified context
5237    (but skips any tag-transparent contexts to find one that is
5238    meaningful for tags).
5239    FORM says which kind of type the caller wants;
5240    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5241    If the wrong kind of type is found, and it's not a template, an error is
5242    reported.  */
5243
5244 static tree
5245 lookup_tag (form, name, binding_level, thislevel_only)
5246      enum tree_code form;
5247      tree name;
5248      struct binding_level *binding_level;
5249      int thislevel_only;
5250 {
5251   register struct binding_level *level;
5252   /* Non-zero if, we should look past a template parameter level, even
5253      if THISLEVEL_ONLY.  */
5254   int allow_template_parms_p = 1;
5255
5256   for (level = binding_level; level; level = level->level_chain)
5257     {
5258       register tree tail;
5259       if (ANON_AGGRNAME_P (name))
5260         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5261           {
5262             /* There's no need for error checking here, because
5263                anon names are unique throughout the compilation.  */
5264             if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
5265               return TREE_VALUE (tail);
5266           }
5267       else if (level->namespace_p)
5268         /* Do namespace lookup. */
5269         for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
5270           {
5271             tree old = binding_for_name (name, tail);
5272
5273             /* If we just skipped past a template parameter level,
5274                even though THISLEVEL_ONLY, and we find a template
5275                class declaration, then we use the _TYPE node for the
5276                template.  See the example below.  */
5277             if (thislevel_only && !allow_template_parms_p
5278                 && old && BINDING_VALUE (old)
5279                 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
5280               old = TREE_TYPE (BINDING_VALUE (old));
5281             else
5282               old = BINDING_TYPE (old);
5283
5284             /* If it has an original type, it is a typedef, and we
5285                should not return it.  */
5286             if (old && DECL_ORIGINAL_TYPE (TYPE_NAME (old)))
5287               old = NULL_TREE;
5288             if (old && TREE_CODE (old) != form
5289                 && !(form != ENUMERAL_TYPE && TREE_CODE (old) == TEMPLATE_DECL))
5290               {
5291                 cp_error ("`%#D' redeclared as %C", old, form);
5292                 return NULL_TREE;
5293               }
5294             if (old)
5295               return old;
5296             if (thislevel_only || tail == global_namespace)
5297               return NULL_TREE;
5298           }
5299       else
5300         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5301           {
5302             if (TREE_PURPOSE (tail) == name)
5303               {
5304                 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5305                 /* Should tighten this up; it'll probably permit
5306                    UNION_TYPE and a struct template, for example.  */
5307                 if (code != form
5308                     && !(form != ENUMERAL_TYPE && code == TEMPLATE_DECL))
5309                   {
5310                     /* Definition isn't the kind we were looking for.  */
5311                     cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
5312                               form);
5313                     return NULL_TREE;
5314                   }
5315                 return TREE_VALUE (tail);
5316               }
5317           }
5318       if (thislevel_only && ! level->tag_transparent)
5319         {
5320           if (level->template_parms_p && allow_template_parms_p)
5321             {
5322               /* We must deal with cases like this:
5323
5324                    template <class T> struct S;
5325                    template <class T> struct S {};
5326
5327                  When looking up `S', for the second declaration, we
5328                  would like to find the first declaration.  But, we
5329                  are in the pseudo-global level created for the
5330                  template parameters, rather than the (surrounding)
5331                  namespace level.  Thus, we keep going one more level,
5332                  even though THISLEVEL_ONLY is non-zero.  */
5333               allow_template_parms_p = 0;
5334               continue;
5335             }
5336           else
5337             return NULL_TREE;
5338         }
5339     }
5340   return NULL_TREE;
5341 }
5342
5343 #if 0
5344 void
5345 set_current_level_tags_transparency (tags_transparent)
5346      int tags_transparent;
5347 {
5348   current_binding_level->tag_transparent = tags_transparent;
5349 }
5350 #endif
5351
5352 /* Given a type, find the tag that was defined for it and return the tag name.
5353    Otherwise return 0.  However, the value can never be 0
5354    in the cases in which this is used.
5355
5356    C++: If NAME is non-zero, this is the new name to install.  This is
5357    done when replacing anonymous tags with real tag names.  */
5358
5359 static tree
5360 lookup_tag_reverse (type, name)
5361      tree type;
5362      tree name;
5363 {
5364   register struct binding_level *level;
5365
5366   for (level = current_binding_level; level; level = level->level_chain)
5367     {
5368       register tree tail;
5369       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5370         {
5371           if (TREE_VALUE (tail) == type)
5372             {
5373               if (name)
5374                 TREE_PURPOSE (tail) = name;
5375               return TREE_PURPOSE (tail);
5376             }
5377         }
5378     }
5379   return NULL_TREE;
5380 }
5381 \f
5382 /* Look up NAME in the NAMESPACE.  */
5383
5384 tree
5385 lookup_namespace_name (namespace, name)
5386      tree namespace, name;
5387 {
5388   tree val;
5389   tree template_id = NULL_TREE;
5390
5391   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5392
5393   if (TREE_CODE (name) == NAMESPACE_DECL)
5394     /* This happens for A::B<int> when B is a namespace. */
5395     return name;
5396   else if (TREE_CODE (name) == TEMPLATE_DECL)
5397     {
5398       /* This happens for A::B where B is a template, and there are no
5399          template arguments.  */
5400       cp_error ("invalid use of `%D'", name);
5401       return error_mark_node;
5402     }
5403
5404   namespace = ORIGINAL_NAMESPACE (namespace);
5405
5406   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5407     {
5408       template_id = name;
5409       name = TREE_OPERAND (name, 0);
5410       if (TREE_CODE (name) == OVERLOAD)
5411         name = DECL_NAME (OVL_CURRENT (name));
5412       else if (DECL_P (name))
5413         name = DECL_NAME (name);
5414     }
5415
5416   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5417
5418   val = make_node (CPLUS_BINDING);
5419   if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5420     return error_mark_node;
5421
5422   if (BINDING_VALUE (val))
5423     {
5424       val = BINDING_VALUE (val);
5425
5426       if (template_id)
5427         {
5428           if (DECL_CLASS_TEMPLATE_P (val))
5429             val = lookup_template_class (val,
5430                                          TREE_OPERAND (template_id, 1),
5431                                          /*in_decl=*/NULL_TREE,
5432                                          /*context=*/NULL_TREE,
5433                                          /*entering_scope=*/0);
5434           else if (DECL_FUNCTION_TEMPLATE_P (val)
5435                    || TREE_CODE (val) == OVERLOAD)
5436             val = lookup_template_function (val,
5437                                             TREE_OPERAND (template_id, 1));
5438           else
5439             {
5440               cp_error ("`%D::%D' is not a template",
5441                         namespace, name);
5442               return error_mark_node;
5443             }
5444         }
5445
5446       /* If we have a single function from a using decl, pull it out.  */
5447       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5448         val = OVL_FUNCTION (val);
5449       return val;
5450     }
5451
5452   cp_error ("`%D' undeclared in namespace `%D'", name, namespace);
5453   return error_mark_node;
5454 }
5455
5456 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
5457
5458 static unsigned long
5459 typename_hash (k)
5460      hash_table_key k;
5461 {
5462   unsigned long hash;
5463   tree t;
5464
5465   t = (tree) k;
5466   hash = (((unsigned long) TYPE_CONTEXT (t))
5467           ^ ((unsigned long) DECL_NAME (TYPE_NAME (t))));
5468
5469   return hash;
5470 }
5471
5472 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
5473
5474 static boolean
5475 typename_compare (k1, k2)
5476      hash_table_key k1;
5477      hash_table_key k2;
5478 {
5479   tree t1;
5480   tree t2;
5481   tree d1;
5482   tree d2;
5483
5484   t1 = (tree) k1;
5485   t2 = (tree) k2;
5486   d1 = TYPE_NAME (t1);
5487   d2 = TYPE_NAME (t2);
5488
5489   return (DECL_NAME (d1) == DECL_NAME (d2)
5490           && same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))
5491           && ((TREE_TYPE (t1) != NULL_TREE)
5492               == (TREE_TYPE (t2) != NULL_TREE))
5493           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5494           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5495 }
5496
5497 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
5498    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
5499    is non-NULL, this type is being created by the implicit typename
5500    extension, and BASE_TYPE is a type named `t' in some base class of
5501    `T' which depends on template parameters.
5502
5503    Returns the new TYPENAME_TYPE.  */
5504
5505 tree
5506 build_typename_type (context, name, fullname, base_type)
5507      tree context;
5508      tree name;
5509      tree fullname;
5510      tree base_type;
5511 {
5512   tree t;
5513   tree d;
5514   struct hash_entry* e;
5515
5516   static struct hash_table ht;
5517
5518   if (!ht.table)
5519     {
5520       static struct hash_table *h = &ht;
5521       if (!hash_table_init (&ht, &hash_newfunc, &typename_hash,
5522                             &typename_compare))
5523         fatal ("virtual memory exhausted");
5524       ggc_add_tree_hash_table_root (&h, 1);
5525     }
5526
5527   /* Build the TYPENAME_TYPE.  */
5528   t = make_aggr_type (TYPENAME_TYPE);
5529   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5530   TYPENAME_TYPE_FULLNAME (t) = fullname;
5531   TREE_TYPE (t) = base_type;
5532
5533   /* Build the corresponding TYPE_DECL.  */
5534   d = build_decl (TYPE_DECL, name, t);
5535   TYPE_NAME (TREE_TYPE (d)) = d;
5536   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5537   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5538   DECL_ARTIFICIAL (d) = 1;
5539
5540   /* See if we already have this type.  */
5541   e = hash_lookup (&ht, t, /*create=*/false, /*copy=*/0);
5542   if (e)
5543     t = (tree) e->key;
5544   else
5545     /* Insert the type into the table.  */
5546     hash_lookup (&ht, t, /*create=*/true, /*copy=*/0);
5547
5548   return t;
5549 }
5550
5551 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
5552    unless an error occurs, in which case error_mark_node is returned.
5553    If COMPLAIN zero, don't complain about any errors that occur.  */
5554
5555 tree
5556 make_typename_type (context, name, complain)
5557      tree context, name;
5558      int complain;
5559 {
5560   tree fullname;
5561
5562   if (TYPE_P (name))
5563     {
5564       if (!(TYPE_LANG_SPECIFIC (name)
5565             && (CLASSTYPE_IS_TEMPLATE (name)
5566                 || CLASSTYPE_USE_TEMPLATE (name))))
5567         name = TYPE_IDENTIFIER (name);
5568       else
5569         /* Create a TEMPLATE_ID_EXPR for the type.  */
5570         name = build_nt (TEMPLATE_ID_EXPR,
5571                          CLASSTYPE_TI_TEMPLATE (name),
5572                          CLASSTYPE_TI_ARGS (name));
5573     }
5574   else if (TREE_CODE (name) == TYPE_DECL)
5575     name = DECL_NAME (name);
5576
5577   fullname = name;
5578
5579   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5580     {
5581       name = TREE_OPERAND (name, 0);
5582       if (TREE_CODE (name) == TEMPLATE_DECL)
5583         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5584     }
5585   if (TREE_CODE (name) != IDENTIFIER_NODE)
5586     my_friendly_abort (2000);
5587
5588   if (TREE_CODE (context) == NAMESPACE_DECL)
5589     {
5590       /* We can get here from typename_sub0 in the explicit_template_type
5591          expansion.  Just fail.  */
5592       if (complain)
5593         cp_error ("no class template named `%#T' in `%#T'",
5594                   name, context);
5595       return error_mark_node;
5596     }
5597
5598   if (! uses_template_parms (context)
5599       || currently_open_class (context))
5600     {
5601       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5602         {
5603           tree tmpl = NULL_TREE;
5604           if (IS_AGGR_TYPE (context))
5605             tmpl = lookup_field (context, name, 0, 0);
5606           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5607             {
5608               if (complain)
5609                 cp_error ("no class template named `%#T' in `%#T'",
5610                           name, context);
5611               return error_mark_node;
5612             }
5613
5614           return lookup_template_class (tmpl,
5615                                         TREE_OPERAND (fullname, 1),
5616                                         NULL_TREE, context,
5617                                         /*entering_scope=*/0);
5618         }
5619       else
5620         {
5621           tree t;
5622
5623           if (!IS_AGGR_TYPE (context))
5624             {
5625               if (complain)
5626                 cp_error ("no type named `%#T' in `%#T'", name, context);
5627               return error_mark_node;
5628             }
5629
5630           t = lookup_field (context, name, 0, 1);
5631           if (t)
5632             return TREE_TYPE (t);
5633         }
5634     }
5635
5636   /* If the CONTEXT is not a template type, then either the field is
5637      there now or its never going to be.  */
5638   if (!uses_template_parms (context))
5639     {
5640       if (complain)
5641         cp_error ("no type named `%#T' in `%#T'", name, context);
5642       return error_mark_node;
5643     }
5644
5645
5646   return build_typename_type (context, name, fullname,  NULL_TREE);
5647 }
5648
5649 /* Select the right _DECL from multiple choices. */
5650
5651 static tree
5652 select_decl (binding, flags)
5653      tree binding;
5654      int flags;
5655 {
5656   tree val;
5657   val = BINDING_VALUE (binding);
5658   if (LOOKUP_NAMESPACES_ONLY (flags))
5659     {
5660       /* We are not interested in types. */
5661       if (val && TREE_CODE (val) == NAMESPACE_DECL)
5662         return val;
5663       return NULL_TREE;
5664     }
5665
5666   /* If we could have a type and
5667      we have nothing or we need a type and have none.  */
5668   if (BINDING_TYPE (binding)
5669       && (!val || ((flags & LOOKUP_PREFER_TYPES)
5670                    && TREE_CODE (val) != TYPE_DECL)))
5671     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5672   /* Don't return non-types if we really prefer types. */
5673   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
5674            && (TREE_CODE (val) != TEMPLATE_DECL
5675                || !DECL_CLASS_TEMPLATE_P (val)))
5676     val = NULL_TREE;
5677
5678   return val;
5679 }
5680
5681 /* Unscoped lookup of a global: iterate over current namespaces,
5682    considering using-directives.  If SPACESP is non-NULL, store a list
5683    of the namespaces we've considered in it.  */
5684
5685 tree
5686 unqualified_namespace_lookup (name, flags, spacesp)
5687      tree name;
5688      int flags;
5689      tree *spacesp;
5690 {
5691   tree b = make_node (CPLUS_BINDING);
5692   tree initial = current_decl_namespace();
5693   tree scope = initial;
5694   tree siter;
5695   struct binding_level *level;
5696   tree val = NULL_TREE;
5697
5698   if (spacesp)
5699     *spacesp = NULL_TREE;
5700
5701   for (; !val; scope = CP_DECL_CONTEXT (scope))
5702     {
5703       if (spacesp)
5704         *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5705       val = binding_for_name (name, scope);
5706
5707       /* Initialize binding for this context. */
5708       BINDING_VALUE (b) = BINDING_VALUE (val);
5709       BINDING_TYPE (b) = BINDING_TYPE (val);
5710
5711       /* Add all _DECLs seen through local using-directives. */
5712       for (level = current_binding_level;
5713            !level->namespace_p;
5714            level = level->level_chain)
5715         if (!lookup_using_namespace (name, b, level->using_directives,
5716                                      scope, flags, spacesp))
5717           /* Give up because of error. */
5718           return error_mark_node;
5719
5720       /* Add all _DECLs seen through global using-directives. */
5721       /* XXX local and global using lists should work equally. */
5722       siter = initial;
5723       while (1)
5724         {
5725           if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5726                                        scope, flags, spacesp))
5727             /* Give up because of error. */
5728             return error_mark_node;
5729           if (siter == scope) break;
5730           siter = CP_DECL_CONTEXT (siter);
5731         }
5732
5733       val = select_decl (b, flags);
5734       if (scope == global_namespace)
5735         break;
5736     }
5737   return val;
5738 }
5739
5740 /* Combine prefer_type and namespaces_only into flags.  */
5741
5742 static int
5743 lookup_flags (prefer_type, namespaces_only)
5744   int prefer_type, namespaces_only;
5745 {
5746   if (namespaces_only)
5747     return LOOKUP_PREFER_NAMESPACES;
5748   if (prefer_type > 1)
5749     return LOOKUP_PREFER_TYPES;
5750   if (prefer_type > 0)
5751     return LOOKUP_PREFER_BOTH;
5752   return 0;
5753 }
5754
5755 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5756    ignore it or not.  Subroutine of lookup_name_real.  */
5757
5758 static tree
5759 qualify_lookup (val, flags)
5760      tree val;
5761      int flags;
5762 {
5763   if (val == NULL_TREE)
5764     return val;
5765   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5766     return val;
5767   if ((flags & LOOKUP_PREFER_TYPES)
5768       && (TREE_CODE (val) == TYPE_DECL
5769           || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5770               && DECL_CLASS_TEMPLATE_P (val))))
5771     return val;
5772   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5773     return NULL_TREE;
5774   return val;
5775 }
5776
5777 /* Any other BINDING overrides an implicit TYPENAME.  Warn about
5778    that.  */
5779
5780 static void
5781 warn_about_implicit_typename_lookup (typename, binding)
5782      tree typename;
5783      tree binding;
5784 {
5785   tree subtype = TREE_TYPE (TREE_TYPE (typename));
5786   tree name = DECL_NAME (typename);
5787
5788   if (! (TREE_CODE (binding) == TEMPLATE_DECL
5789          && CLASSTYPE_TEMPLATE_INFO (subtype)
5790          && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
5791       && ! (TREE_CODE (binding) == TYPE_DECL
5792             && same_type_p (TREE_TYPE (binding), subtype)))
5793     {
5794       cp_warning ("lookup of `%D' finds `%#D'",
5795                   name, binding);
5796       cp_warning ("  instead of `%D' from dependent base class",
5797                   typename);
5798       cp_warning ("  (use `typename %T::%D' if that's what you meant)",
5799                   constructor_name (current_class_type), name);
5800     }
5801 }
5802
5803 /* Look up NAME in the current binding level and its superiors in the
5804    namespace of variables, functions and typedefs.  Return a ..._DECL
5805    node of some kind representing its definition if there is only one
5806    such declaration, or return a TREE_LIST with all the overloaded
5807    definitions if there are many, or return 0 if it is undefined.
5808
5809    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5810    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5811    If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5812    Otherwise we prefer non-TYPE_DECLs.
5813
5814    If NONCLASS is non-zero, we don't look for the NAME in class scope,
5815    using IDENTIFIER_CLASS_VALUE.  */
5816
5817 static tree
5818 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
5819      tree name;
5820      int prefer_type, nonclass, namespaces_only;
5821 {
5822   tree t;
5823   tree val = NULL_TREE;
5824   int yylex = 0;
5825   tree from_obj = NULL_TREE;
5826   int flags;
5827   int val_is_implicit_typename = 0;
5828
5829   /* Hack: copy flag set by parser, if set. */
5830   if (only_namespace_names)
5831     namespaces_only = 1;
5832
5833   if (prefer_type == -2)
5834     {
5835       extern int looking_for_typename;
5836       tree type = NULL_TREE;
5837
5838       yylex = 1;
5839       prefer_type = looking_for_typename;
5840
5841       flags = lookup_flags (prefer_type, namespaces_only);
5842       /* If the next thing is '<', class templates are types. */
5843       if (looking_for_template)
5844         flags |= LOOKUP_TEMPLATES_EXPECTED;
5845
5846       /* std:: becomes :: for now.  */
5847       if (got_scope == std_node)
5848         got_scope = void_type_node;
5849
5850       if (got_scope)
5851         type = got_scope;
5852       else if (got_object != error_mark_node)
5853         type = got_object;
5854
5855       if (type)
5856         {
5857           if (type == error_mark_node)
5858             return error_mark_node;
5859           if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
5860             type = TREE_TYPE (type);
5861
5862           if (TYPE_P (type))
5863             type = complete_type (type);
5864
5865           if (TREE_CODE (type) == VOID_TYPE)
5866             type = global_namespace;
5867           if (TREE_CODE (type) == NAMESPACE_DECL)
5868             {
5869               val = make_node (CPLUS_BINDING);
5870               flags |= LOOKUP_COMPLAIN;
5871               if (!qualified_lookup_using_namespace (name, type, val, flags))
5872                 return NULL_TREE;
5873               val = select_decl (val, flags);
5874             }
5875           else if (! IS_AGGR_TYPE (type)
5876                    || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5877                    || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM
5878                    || TREE_CODE (type) == TYPENAME_TYPE)
5879             /* Someone else will give an error about this if needed.  */
5880             val = NULL_TREE;
5881           else if (type == current_class_type)
5882             val = IDENTIFIER_CLASS_VALUE (name);
5883           else
5884             {
5885               val = lookup_member (type, name, 0, prefer_type);
5886               type_access_control (type, val);
5887             }
5888         }
5889       else
5890         val = NULL_TREE;
5891
5892       if (got_scope)
5893         goto done;
5894       else if (got_object && val)
5895         from_obj = val;
5896     }
5897   else
5898     {
5899       flags = lookup_flags (prefer_type, namespaces_only);
5900       /* If we're not parsing, we need to complain. */
5901       flags |= LOOKUP_COMPLAIN;
5902     }
5903
5904   /* First, look in non-namespace scopes.  */
5905
5906   if (current_class_type == NULL_TREE)
5907     nonclass = 1;
5908
5909   for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
5910     {
5911       tree binding;
5912
5913       if (!LOCAL_BINDING_P (t) && nonclass)
5914         /* We're not looking for class-scoped bindings, so keep going.  */
5915         continue;
5916
5917       /* If this is the kind of thing we're looking for, we're done.  */
5918       if (qualify_lookup (BINDING_VALUE (t), flags))
5919         binding = BINDING_VALUE (t);
5920       else if ((flags & LOOKUP_PREFER_TYPES)
5921                && qualify_lookup (BINDING_TYPE (t), flags))
5922         binding = BINDING_TYPE (t);
5923       else
5924         binding = NULL_TREE;
5925
5926       /* Handle access control on types from enclosing or base classes.  */
5927       if (binding && ! yylex
5928           && BINDING_LEVEL (t) && BINDING_LEVEL (t)->parm_flag == 2)
5929         type_access_control (BINDING_LEVEL (t)->this_class, binding);
5930
5931       if (binding
5932           && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
5933         {
5934           if (val_is_implicit_typename && !yylex)
5935             warn_about_implicit_typename_lookup (val, binding);
5936           val = binding;
5937           val_is_implicit_typename
5938             = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
5939           if (!val_is_implicit_typename)
5940             break;
5941         }
5942     }
5943
5944   /* Now lookup in namespace scopes.  */
5945   if (!val || val_is_implicit_typename)
5946     {
5947       t = unqualified_namespace_lookup (name, flags, 0);
5948       if (t)
5949         {
5950           if (val_is_implicit_typename && !yylex)
5951             warn_about_implicit_typename_lookup (val, t);
5952           val = t;
5953         }
5954     }
5955
5956  done:
5957   if (val)
5958     {
5959       /* This should only warn about types used in qualified-ids.  */
5960       if (from_obj && from_obj != val)
5961         {
5962           if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
5963               && TREE_CODE (val) == TYPE_DECL
5964               && TREE_TYPE (from_obj) != TREE_TYPE (val))
5965             {
5966               cp_pedwarn ("lookup of `%D' in the scope of `%#T' (`%#T')",
5967                           name, got_object, TREE_TYPE (from_obj));
5968               cp_pedwarn ("  does not match lookup in the current scope (`%#T')",
5969                           TREE_TYPE (val));
5970             }
5971
5972           /* We don't change val to from_obj if got_object depends on
5973              template parms because that breaks implicit typename for
5974              destructor calls.  */
5975           if (! uses_template_parms (got_object))
5976             val = from_obj;
5977         }
5978
5979       /* If we have a single function from a using decl, pull it out.  */
5980       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5981         val = OVL_FUNCTION (val);
5982     }
5983   else if (from_obj)
5984     val = from_obj;
5985
5986   return val;
5987 }
5988
5989 tree
5990 lookup_name_nonclass (name)
5991      tree name;
5992 {
5993   return lookup_name_real (name, 0, 1, 0);
5994 }
5995
5996 tree
5997 lookup_function_nonclass (name, args)
5998      tree name;
5999      tree args;
6000 {
6001   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
6002 }
6003
6004 tree
6005 lookup_name_namespace_only (name)
6006      tree name;
6007 {
6008   /* type-or-namespace, nonclass, namespace_only */
6009   return lookup_name_real (name, 1, 1, 1);
6010 }
6011
6012 tree
6013 lookup_name (name, prefer_type)
6014      tree name;
6015      int prefer_type;
6016 {
6017   return lookup_name_real (name, prefer_type, 0, 0);
6018 }
6019
6020 /* Similar to `lookup_name' but look only in the innermost non-class
6021    binding level.  */
6022
6023 tree
6024 lookup_name_current_level (name)
6025      tree name;
6026 {
6027   struct binding_level *b;
6028   tree t = NULL_TREE;
6029
6030   b = current_binding_level;
6031   while (b->parm_flag == 2)
6032     b = b->level_chain;
6033
6034   if (b->namespace_p)
6035     {
6036       t = IDENTIFIER_NAMESPACE_VALUE (name);
6037
6038       /* extern "C" function() */
6039       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
6040         t = TREE_VALUE (t);
6041     }
6042   else if (IDENTIFIER_BINDING (name)
6043            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
6044     {
6045       while (1)
6046         {
6047           if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
6048             return IDENTIFIER_VALUE (name);
6049
6050           if (b->keep == 2)
6051             b = b->level_chain;
6052           else
6053             break;
6054         }
6055     }
6056
6057   return t;
6058 }
6059
6060 /* Like lookup_name_current_level, but for types.  */
6061
6062 tree
6063 lookup_type_current_level (name)
6064      tree name;
6065 {
6066   register tree t = NULL_TREE;
6067
6068   my_friendly_assert (! current_binding_level->namespace_p, 980716);
6069
6070   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
6071       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
6072     {
6073       struct binding_level *b = current_binding_level;
6074       while (1)
6075         {
6076           if (purpose_member (name, b->type_shadowed))
6077             return REAL_IDENTIFIER_TYPE_VALUE (name);
6078           if (b->keep == 2)
6079             b = b->level_chain;
6080           else
6081             break;
6082         }
6083     }
6084
6085   return t;
6086 }
6087
6088 void
6089 begin_only_namespace_names ()
6090 {
6091   only_namespace_names = 1;
6092 }
6093
6094 void
6095 end_only_namespace_names ()
6096 {
6097   only_namespace_names = 0;
6098 }
6099 \f
6100 /* Arrange for the user to get a source line number, even when the
6101    compiler is going down in flames, so that she at least has a
6102    chance of working around problems in the compiler.  We used to
6103    call error(), but that let the segmentation fault continue
6104    through; now, it's much more passive by asking them to send the
6105    maintainers mail about the problem.  */
6106
6107 static void
6108 signal_catch (sig)
6109      int sig ATTRIBUTE_UNUSED;
6110 {
6111   signal (SIGSEGV, SIG_DFL);
6112 #ifdef SIGIOT
6113   signal (SIGIOT, SIG_DFL);
6114 #endif
6115 #ifdef SIGILL
6116   signal (SIGILL, SIG_DFL);
6117 #endif
6118 #ifdef SIGABRT
6119   signal (SIGABRT, SIG_DFL);
6120 #endif
6121 #ifdef SIGBUS
6122   signal (SIGBUS, SIG_DFL);
6123 #endif
6124   my_friendly_abort (0);
6125 }
6126
6127 /* Push the declarations of builtin types into the namespace.
6128    RID_INDEX, if < CP_RID_MAX is the index of the builtin type
6129    in the array RID_POINTERS.  NAME is the name used when looking
6130    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
6131
6132 static void
6133 record_builtin_type (rid_index, name, type)
6134      enum rid rid_index;
6135      const char *name;
6136      tree type;
6137 {
6138   tree rname = NULL_TREE, tname = NULL_TREE;
6139   tree tdecl = NULL_TREE;
6140
6141   if ((int) rid_index < (int) CP_RID_MAX)
6142     rname = ridpointers[(int) rid_index];
6143   if (name)
6144     tname = get_identifier (name);
6145
6146   TYPE_BUILT_IN (type) = 1;
6147
6148   if (tname)
6149     {
6150       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
6151       set_identifier_type_value (tname, NULL_TREE);
6152       if ((int) rid_index < (int) CP_RID_MAX)
6153         /* Built-in types live in the global namespace. */
6154         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
6155     }
6156   if (rname != NULL_TREE)
6157     {
6158       if (tname != NULL_TREE)
6159         {
6160           set_identifier_type_value (rname, NULL_TREE);
6161           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
6162         }
6163       else
6164         {
6165           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
6166           set_identifier_type_value (rname, NULL_TREE);
6167         }
6168     }
6169 }
6170
6171 /* Record one of the standard Java types.
6172  * Declare it as having the given NAME.
6173  * If SIZE > 0, it is the size of one of the integral types;
6174  * otherwise it is the negative of the size of one of the other types.  */
6175
6176 static tree
6177 record_builtin_java_type (name, size)
6178      const char *name;
6179      int size;
6180 {
6181   tree type, decl;
6182   if (size > 0)
6183     type = make_signed_type (size);
6184   else if (size > -32)
6185     { /* "__java_char" or ""__java_boolean". */
6186       type = make_unsigned_type (-size);
6187       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6188     }
6189   else
6190     { /* "__java_float" or ""__java_double". */
6191       type = make_node (REAL_TYPE);
6192       TYPE_PRECISION (type) = - size;
6193       layout_type (type);
6194     }
6195   record_builtin_type (CP_RID_MAX, name, type);
6196   decl = TYPE_NAME (type);
6197
6198   /* Suppress generate debug symbol entries for these types,
6199      since for normal C++ they are just clutter.
6200      However, push_lang_context undoes this if extern "Java" is seen. */
6201   DECL_IGNORED_P (decl) = 1;
6202
6203   TYPE_FOR_JAVA (type) = 1;
6204   return type;
6205 }
6206
6207 /* Push a type into the namespace so that the back-ends ignore it. */
6208
6209 static void
6210 record_unknown_type (type, name)
6211      tree type;
6212      const char *name;
6213 {
6214   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
6215   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
6216   DECL_IGNORED_P (decl) = 1;
6217   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6218   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
6219   TYPE_ALIGN (type) = 1;
6220   TYPE_USER_ALIGN (type) = 0;
6221   TYPE_MODE (type) = TYPE_MODE (void_type_node);
6222 }
6223
6224 /* An string for which we should create an IDENTIFIER_NODE at
6225    startup.  */
6226
6227 typedef struct predefined_identifier
6228 {
6229   /* The name of the identifier.  */
6230   const char *name;
6231   /* The place where the IDENTIFIER_NODE should be stored.  */
6232   tree *node;
6233   /* Non-zero if this is the name of a constructor or destructor.  */
6234   int ctor_or_dtor_p;
6235 } predefined_identifier;
6236
6237 /* Create all the predefined identifiers.  */
6238
6239 static void
6240 initialize_predefined_identifiers ()
6241 {
6242   struct predefined_identifier *pid;
6243
6244   /* A table of identifiers to create at startup.  */
6245   static predefined_identifier predefined_identifiers[] = {
6246     { "C++", &lang_name_cplusplus, 0 },
6247     { "C", &lang_name_c, 0 },
6248     { "Java", &lang_name_java, 0 },
6249     { CTOR_NAME, &ctor_identifier, 1 },
6250     { "__base_ctor", &base_ctor_identifier, 1 },
6251     { "__comp_ctor", &complete_ctor_identifier, 1 },
6252     { DTOR_NAME, &dtor_identifier, 1 },
6253     { "__comp_dtor", &complete_dtor_identifier, 1 },
6254     { "__base_dtor", &base_dtor_identifier, 1 },
6255     { "__deleting_dtor", &deleting_dtor_identifier, 1 },
6256     { VTABLE_DELTA2_NAME, &delta2_identifier, 0 },
6257     { VTABLE_DELTA_NAME, &delta_identifier, 0 },
6258     { IN_CHARGE_NAME, &in_charge_identifier, 0 },
6259     { VTABLE_INDEX_NAME, &index_identifier, 0 },
6260     { "nelts", &nelts_identifier, 0 },
6261     { THIS_NAME, &this_identifier, 0 },
6262     { VTABLE_PFN_NAME, &pfn_identifier, 0 },
6263     { "__pfn_or_delta2", &pfn_or_delta2_identifier, 0 },
6264     { "_vptr", &vptr_identifier, 0 },
6265     { "__cp_push_exception", &cp_push_exception_identifier, 0 },
6266     { "__vtt_parm", &vtt_parm_identifier, 0 },
6267     { "std", &std_identifier, 0 },
6268     { NULL, NULL, 0 }
6269   };
6270
6271   for (pid = predefined_identifiers; pid->name; ++pid)
6272     {
6273       *pid->node = get_identifier (pid->name);
6274       if (pid->ctor_or_dtor_p)
6275         IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
6276     }
6277 }
6278
6279 /* Create the predefined scalar types of C,
6280    and some nodes representing standard constants (0, 1, (void *)0).
6281    Initialize the global binding level.
6282    Make definitions for built-in primitive functions.  */
6283
6284 void
6285 init_decl_processing ()
6286 {
6287   tree fields[20];
6288   int wchar_type_size;
6289   tree array_domain_type;
6290
6291   /* Check to see that the user did not specify an invalid combination
6292      of command-line options.  */
6293   if (flag_new_abi && !flag_vtable_thunks)
6294     fatal ("the new ABI requires vtable thunks");
6295
6296   /* Create all the identifiers we need.  */
6297   initialize_predefined_identifiers ();
6298
6299   /* Let the back-end now how to save and restore language-specific
6300      per-function globals.  */
6301   init_lang_status = &push_cp_function_context;
6302   free_lang_status = &pop_cp_function_context;
6303   mark_lang_status = &mark_cp_function_context;
6304
6305   cp_parse_init ();
6306   init_decl2 ();
6307   init_pt ();
6308
6309   /* Create the global variables.  */
6310   push_to_top_level ();
6311
6312   /* Enter the global namespace. */
6313   my_friendly_assert (global_namespace == NULL_TREE, 375);
6314   push_namespace (get_identifier ("::"));
6315   global_namespace = current_namespace;
6316   current_lang_name = NULL_TREE;
6317
6318   /* Adjust various flags based on command-line settings.  */
6319   if (flag_strict_prototype == 2)
6320     flag_strict_prototype = pedantic;
6321   if (! flag_permissive && ! pedantic)
6322     flag_pedantic_errors = 1;
6323   if (!flag_no_inline)
6324     flag_inline_trees = 1;
6325
6326   strict_prototypes_lang_c = flag_strict_prototype;
6327
6328   /* Initially, C.  */
6329   current_lang_name = lang_name_c;
6330
6331   current_function_decl = NULL_TREE;
6332   current_binding_level = NULL_BINDING_LEVEL;
6333   free_binding_level = NULL_BINDING_LEVEL;
6334
6335   /* Because most segmentation signals can be traced back into user
6336      code, catch them and at least give the user a chance of working
6337      around compiler bugs.  */
6338   signal (SIGSEGV, signal_catch);
6339
6340   /* We will also catch aborts in the back-end through signal_catch and
6341      give the user a chance to see where the error might be, and to defeat
6342      aborts in the back-end when there have been errors previously in their
6343      code.  */
6344 #ifdef SIGIOT
6345   signal (SIGIOT, signal_catch);
6346 #endif
6347 #ifdef SIGILL
6348   signal (SIGILL, signal_catch);
6349 #endif
6350 #ifdef SIGABRT
6351   signal (SIGABRT, signal_catch);
6352 #endif
6353 #ifdef SIGBUS
6354   signal (SIGBUS, signal_catch);
6355 #endif
6356
6357   build_common_tree_nodes (flag_signed_char);
6358
6359   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6360   TREE_TYPE (error_mark_list) = error_mark_node;
6361
6362   /* Make the binding_level structure for global names.  */
6363   pushlevel (0);
6364   global_binding_level = current_binding_level;
6365   /* The global level is the namespace level of ::.  */
6366   NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6367   declare_namespace_level ();
6368
6369   /* Define `int' and `char' first so that dbx will output them first.  */
6370   record_builtin_type (RID_INT, NULL_PTR, integer_type_node);
6371   record_builtin_type (RID_CHAR, "char", char_type_node);
6372
6373   /* `signed' is the same as `int' */
6374   record_builtin_type (RID_SIGNED, NULL_PTR, integer_type_node);
6375   record_builtin_type (RID_LONG, "long int", long_integer_type_node);
6376   record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
6377   record_builtin_type (CP_RID_MAX, "long unsigned int",
6378                        long_unsigned_type_node);
6379   record_builtin_type (CP_RID_MAX, "unsigned long", long_unsigned_type_node);
6380   record_builtin_type (CP_RID_MAX, "long long int",
6381                        long_long_integer_type_node);
6382   record_builtin_type (CP_RID_MAX, "long long unsigned int",
6383                        long_long_unsigned_type_node);
6384   record_builtin_type (CP_RID_MAX, "long long unsigned",
6385                        long_long_unsigned_type_node);
6386   record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
6387   record_builtin_type (CP_RID_MAX, "short unsigned int",
6388                        short_unsigned_type_node);
6389   record_builtin_type (CP_RID_MAX, "unsigned short",
6390                        short_unsigned_type_node);
6391
6392   ptrdiff_type_node
6393     = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE)));
6394
6395   /* Define both `signed char' and `unsigned char'.  */
6396   record_builtin_type (CP_RID_MAX, "signed char", signed_char_type_node);
6397   record_builtin_type (CP_RID_MAX, "unsigned char", unsigned_char_type_node);
6398
6399   /* `unsigned long' is the standard type for sizeof.
6400      Note that stddef.h uses `unsigned long',
6401      and this must agree, even if long and int are the same size.  */
6402   set_sizetype
6403     (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE))));
6404
6405   /* Create the widest literal types. */
6406   widest_integer_literal_type_node = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
6407   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6408                         widest_integer_literal_type_node));
6409
6410   widest_unsigned_literal_type_node = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
6411   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6412                         widest_unsigned_literal_type_node));
6413
6414   /* These are types that type_for_size and type_for_mode use.  */
6415   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
6416   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
6417   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
6418   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
6419 #if HOST_BITS_PER_WIDE_INT >= 64
6420   pushdecl (build_decl (TYPE_DECL, get_identifier ("__int128_t"), intTI_type_node));
6421 #endif
6422   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
6423   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
6424   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
6425   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
6426 #if HOST_BITS_PER_WIDE_INT >= 64
6427   pushdecl (build_decl (TYPE_DECL, get_identifier ("__uint128_t"), unsigned_intTI_type_node));
6428 #endif
6429
6430   build_common_tree_nodes_2 (flag_short_double);
6431
6432   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6433   java_short_type_node = record_builtin_java_type ("__java_short", 16);
6434   java_int_type_node = record_builtin_java_type ("__java_int", 32);
6435   java_long_type_node = record_builtin_java_type ("__java_long", 64);
6436   java_float_type_node = record_builtin_java_type ("__java_float", -32);
6437   java_double_type_node = record_builtin_java_type ("__java_double", -64);
6438   java_char_type_node = record_builtin_java_type ("__java_char", -16);
6439   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6440
6441   integer_two_node = build_int_2 (2, 0);
6442   TREE_TYPE (integer_two_node) = integer_type_node;
6443   integer_three_node = build_int_2 (3, 0);
6444   TREE_TYPE (integer_three_node) = integer_type_node;
6445
6446   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6447   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6448   TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6449   TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6450   TYPE_PRECISION (boolean_type_node) = 1;
6451   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6452   boolean_false_node = build_int_2 (0, 0);
6453   TREE_TYPE (boolean_false_node) = boolean_type_node;
6454   boolean_true_node = build_int_2 (1, 0);
6455   TREE_TYPE (boolean_true_node) = boolean_type_node;
6456
6457   signed_size_zero_node = build_int_2 (0, 0);
6458   record_builtin_type (RID_FLOAT, NULL_PTR, float_type_node);
6459   record_builtin_type (RID_DOUBLE, NULL_PTR, double_type_node);
6460   record_builtin_type (CP_RID_MAX, "long double", long_double_type_node);
6461
6462   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
6463                         complex_integer_type_node));
6464   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
6465                         complex_float_type_node));
6466   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),
6467                         complex_double_type_node));
6468   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
6469                         complex_long_double_type_node));
6470
6471   TREE_TYPE (signed_size_zero_node) = make_signed_type (TYPE_PRECISION (sizetype));
6472
6473   record_builtin_type (RID_VOID, NULL_PTR, void_type_node);
6474   void_list_node = build_tree_list (NULL_TREE, void_type_node);
6475   TREE_PARMLIST (void_list_node) = 1;
6476
6477   /* Used for expressions that do nothing, but are not errors.  */
6478   void_zero_node = build_int_2 (0, 0);
6479   TREE_TYPE (void_zero_node) = void_type_node;
6480
6481   string_type_node = build_pointer_type (char_type_node);
6482   const_string_type_node
6483     = build_pointer_type (build_qualified_type (char_type_node,
6484                                                 TYPE_QUAL_CONST));
6485   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6486 #if 0
6487   record_builtin_type (CP_RID_MAX, NULL_PTR, string_type_node);
6488 #endif
6489
6490   /* Make a type to be the domain of a few array types
6491      whose domains don't really matter.
6492      200 is small enough that it always fits in size_t.  */
6493   array_domain_type = build_index_type (build_int_2 (200, 0));
6494
6495   /* Make a type for arrays of characters.
6496      With luck nothing will ever really depend on the length of this
6497      array type.  */
6498   char_array_type_node
6499     = build_array_type (char_type_node, array_domain_type);
6500
6501   /* Likewise for arrays of ints.  */
6502   int_array_type_node
6503     = build_array_type (integer_type_node, array_domain_type);
6504
6505   if (flag_new_abi)
6506     delta_type_node = ptrdiff_type_node;
6507   else if (flag_huge_objects)
6508     delta_type_node = long_integer_type_node;
6509   else
6510     delta_type_node = short_integer_type_node;
6511
6512   if (flag_new_abi)
6513     vtable_index_type = ptrdiff_type_node;
6514   else
6515     vtable_index_type = delta_type_node;
6516
6517   default_function_type
6518     = build_function_type (integer_type_node, NULL_TREE);
6519
6520   ptr_type_node = build_pointer_type (void_type_node);
6521   const_ptr_type_node
6522     = build_pointer_type (build_qualified_type (void_type_node,
6523                                                 TYPE_QUAL_CONST));
6524   vtt_parm_type = build_pointer_type (const_ptr_type_node);
6525   c_common_nodes_and_builtins (1, flag_no_builtin, flag_no_nonansi_builtin);
6526   lang_type_promotes_to = convert_type_from_ellipsis;
6527
6528   void_ftype_ptr
6529     = build_exception_variant (void_ftype_ptr, empty_except_spec);
6530
6531   /* C++ extensions */
6532
6533   unknown_type_node = make_node (UNKNOWN_TYPE);
6534   record_unknown_type (unknown_type_node, "unknown type");
6535
6536   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
6537   TREE_TYPE (unknown_type_node) = unknown_type_node;
6538
6539   TREE_TYPE (null_node) = type_for_size (POINTER_SIZE, 0);
6540
6541   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6542      result.  */
6543   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6544   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6545
6546   /* This is special for C++ so functions can be overloaded.  */
6547   wchar_type_node = get_identifier (flag_short_wchar
6548                                     ? "short unsigned int"
6549                                     : WCHAR_TYPE);
6550   wchar_type_node = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (wchar_type_node));
6551   wchar_type_size = TYPE_PRECISION (wchar_type_node);
6552   signed_wchar_type_node = make_signed_type (wchar_type_size);
6553   unsigned_wchar_type_node = make_unsigned_type (wchar_type_size);
6554   wchar_type_node
6555     = TREE_UNSIGNED (wchar_type_node)
6556       ? unsigned_wchar_type_node
6557       : signed_wchar_type_node;
6558   record_builtin_type (RID_WCHAR, "__wchar_t", wchar_type_node);
6559
6560   /* Artificial declaration of wchar_t -- can be bashed */
6561   wchar_decl_node = build_decl (TYPE_DECL, get_identifier ("wchar_t"),
6562                                 wchar_type_node);
6563   pushdecl (wchar_decl_node);
6564
6565   /* This is for wide string constants.  */
6566   wchar_array_type_node
6567     = build_array_type (wchar_type_node, array_domain_type);
6568
6569   if (flag_vtable_thunks)
6570     {
6571       /* Make sure we get a unique function type, so we can give
6572          its pointer type a name.  (This wins for gdb.) */
6573       tree vfunc_type = make_node (FUNCTION_TYPE);
6574       TREE_TYPE (vfunc_type) = integer_type_node;
6575       TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6576       layout_type (vfunc_type);
6577
6578       vtable_entry_type = build_pointer_type (vfunc_type);
6579     }
6580   else
6581     {
6582       vtable_entry_type = make_aggr_type (RECORD_TYPE);
6583       fields[0] = build_decl (FIELD_DECL, delta_identifier,
6584                               delta_type_node);
6585       fields[1] = build_decl (FIELD_DECL, index_identifier,
6586                               delta_type_node);
6587       fields[2] = build_decl (FIELD_DECL, pfn_identifier,
6588                               ptr_type_node);
6589       finish_builtin_type (vtable_entry_type, VTBL_PTR_TYPE, fields, 2,
6590                            double_type_node);
6591
6592       /* Make this part of an invisible union.  */
6593       fields[3] = copy_node (fields[2]);
6594       TREE_TYPE (fields[3]) = delta_type_node;
6595       DECL_NAME (fields[3]) = delta2_identifier;
6596       DECL_MODE (fields[3]) = TYPE_MODE (delta_type_node);
6597       DECL_SIZE (fields[3]) = TYPE_SIZE (delta_type_node);
6598       DECL_SIZE_UNIT (fields[3]) = TYPE_SIZE_UNIT (delta_type_node);
6599       TREE_UNSIGNED (fields[3]) = 0;
6600       TREE_CHAIN (fields[2]) = fields[3];
6601       vtable_entry_type = build_qualified_type (vtable_entry_type,
6602                                                 TYPE_QUAL_CONST);
6603     }
6604   record_builtin_type (CP_RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6605
6606   vtbl_type_node
6607     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6608   layout_type (vtbl_type_node);
6609   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6610   record_builtin_type (CP_RID_MAX, NULL_PTR, vtbl_type_node);
6611   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6612   layout_type (vtbl_ptr_type_node);
6613   record_builtin_type (CP_RID_MAX, NULL_PTR, vtbl_ptr_type_node);
6614
6615   std_node = build_decl (NAMESPACE_DECL,
6616                          flag_honor_std
6617                          ? get_identifier ("fake std") : std_identifier,
6618                          void_type_node);
6619   pushdecl (std_node);
6620
6621   if (flag_new_abi)
6622     {
6623       push_namespace (get_identifier ("__cxxabiv1"));
6624       abi_node = current_namespace;
6625       pop_namespace ();
6626     }
6627
6628   global_type_node = make_node (LANG_TYPE);
6629   record_unknown_type (global_type_node, "global type");
6630
6631   /* Now, C++.  */
6632   current_lang_name = lang_name_cplusplus;
6633
6634   {
6635     tree bad_alloc_type_node, newtype, deltype;
6636     if (flag_honor_std)
6637       push_namespace (get_identifier ("std"));
6638     bad_alloc_type_node = xref_tag
6639       (class_type_node, get_identifier ("bad_alloc"), 1);
6640     if (flag_honor_std)
6641       pop_namespace ();
6642     newtype = build_exception_variant
6643       (ptr_ftype_sizetype, add_exception_specifier (NULL_TREE, bad_alloc_type_node, -1));
6644     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6645     push_cp_library_fn (NEW_EXPR, newtype);
6646     push_cp_library_fn (VEC_NEW_EXPR, newtype);
6647     global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
6648     push_cp_library_fn (VEC_DELETE_EXPR, deltype);
6649   }
6650
6651   abort_fndecl
6652     = build_library_fn_ptr ("__pure_virtual", void_ftype);
6653
6654   /* Perform other language dependent initializations.  */
6655   init_class_processing ();
6656   init_init_processing ();
6657   init_search_processing ();
6658   init_rtti_processing ();
6659
6660   if (flag_exceptions)
6661     init_exception_processing ();
6662   if (flag_no_inline)
6663     {
6664       flag_inline_functions = 0;
6665     }
6666
6667   if (! supports_one_only ())
6668     flag_weak = 0;
6669
6670   /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__.  */
6671   make_fname_decl = cp_make_fname_decl;
6672   declare_function_name ();
6673
6674   /* Prepare to check format strings against argument lists.  */
6675   init_function_format_info ();
6676
6677   /* Show we use EH for cleanups.  */
6678   using_eh_for_cleanups ();
6679
6680   print_error_function = lang_print_error_function;
6681   valid_lang_attribute = cp_valid_lang_attribute;
6682
6683   /* Maintain consistency.  Perhaps we should just complain if they
6684      say -fwritable-strings?  */
6685   if (flag_writable_strings)
6686     flag_const_strings = 0;
6687
6688   /* Add GC roots for all of our global variables.  */
6689   ggc_add_tree_root (c_global_trees, sizeof c_global_trees / sizeof(tree));
6690   ggc_add_tree_root (cp_global_trees, sizeof cp_global_trees / sizeof(tree));
6691   ggc_add_tree_root (&integer_three_node, 1);
6692   ggc_add_tree_root (&integer_two_node, 1);
6693   ggc_add_tree_root (&signed_size_zero_node, 1);
6694   ggc_add_tree_root (&size_one_node, 1);
6695   ggc_add_tree_root (&size_zero_node, 1);
6696   ggc_add_root (&global_binding_level, 1, sizeof global_binding_level,
6697                 mark_binding_level);
6698   ggc_add_root (&scope_chain, 1, sizeof scope_chain, &mark_saved_scope);
6699   ggc_add_tree_root (&static_ctors, 1);
6700   ggc_add_tree_root (&static_dtors, 1);
6701   ggc_add_tree_root (&lastiddecl, 1);
6702
6703   ggc_add_tree_root (&last_function_parm_tags, 1);
6704   ggc_add_tree_root (&current_function_return_value, 1);
6705   ggc_add_tree_root (&current_function_parms, 1);
6706   ggc_add_tree_root (&current_function_parm_tags, 1);
6707   ggc_add_tree_root (&last_function_parms, 1);
6708   ggc_add_tree_root (&error_mark_list, 1);
6709
6710   ggc_add_tree_root (&global_namespace, 1);
6711   ggc_add_tree_root (&global_type_node, 1);
6712   ggc_add_tree_root (&anonymous_namespace_name, 1);
6713
6714   ggc_add_tree_root (&got_object, 1);
6715   ggc_add_tree_root (&got_scope, 1);
6716
6717   ggc_add_tree_root (&current_lang_name, 1);
6718   ggc_add_tree_root (&static_aggregates, 1);
6719 }
6720
6721 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6722    decl, NAME is the initialization string and TYPE_DEP indicates whether
6723    NAME depended on the type of the function. We make use of that to detect
6724    __PRETTY_FUNCTION__ inside a template fn.  Because we build a tree for
6725    the function before emitting any of it, we don't need to treat the
6726    VAR_DECL specially. We can decide whether to emit it later, if it was
6727    used.  */
6728
6729 static tree
6730 cp_make_fname_decl (id, name, type_dep)
6731      tree id;
6732      const char *name;
6733      int type_dep;
6734 {
6735   tree decl, type, init;
6736   size_t length = strlen (name);
6737   tree domain = NULL_TREE;
6738
6739   if (!processing_template_decl)
6740     type_dep = 0;
6741   if (!type_dep)
6742     domain = build_index_type (build_int_2 (length, 0));
6743
6744   type =  build_cplus_array_type
6745           (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
6746            domain);
6747
6748   decl = build_decl (VAR_DECL, id, type);
6749   TREE_STATIC (decl) = 1;
6750   TREE_READONLY (decl) = 1;
6751   DECL_SOURCE_LINE (decl) = 0;
6752   DECL_ARTIFICIAL (decl) = 1;
6753   DECL_IN_SYSTEM_HEADER (decl) = 1;
6754   pushdecl (decl);
6755   if (processing_template_decl)
6756     decl = push_template_decl (decl);
6757   if (type_dep)
6758     {
6759       init = build (FUNCTION_NAME, type);
6760       DECL_PRETTY_FUNCTION_P (decl) = 1;
6761     }
6762   else
6763     {
6764       init = build_string (length + 1, name);
6765       TREE_TYPE (init) = type;
6766     }
6767   DECL_INITIAL (decl) = init;
6768   cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
6769
6770   /* We will have to make sure we only emit this, if it is actually used. */
6771   return decl;
6772 }
6773
6774 /* Function to print any language-specific context for an error message.  */
6775
6776 static void
6777 lang_print_error_function (file)
6778      const char *file;
6779 {
6780   default_print_error_function (file);
6781   maybe_print_template_context ();
6782 }
6783
6784 /* Entry point for the benefit of c_common_nodes_and_builtins.
6785
6786    Make a definition for a builtin function named NAME and whose data type
6787    is TYPE.  TYPE should be a function type with argument types.
6788
6789    CLASS and CODE tell later passes how to compile calls to this function.
6790    See tree.h for possible values.
6791
6792    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6793    the name to be called if we can't opencode the function.  */
6794
6795 tree
6796 builtin_function (name, type, code, class, libname)
6797      const char *name;
6798      tree type;
6799      int code;
6800      enum built_in_class class;
6801      const char *libname;
6802 {
6803   tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
6804   DECL_BUILT_IN_CLASS (decl) = class;
6805   DECL_FUNCTION_CODE (decl) = code;
6806
6807   my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 392);
6808
6809   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6810      we cannot change DECL_ASSEMBLER_NAME until we have installed this
6811      function in the namespace.  */
6812   pushdecl (decl);
6813   if (libname)
6814     DECL_ASSEMBLER_NAME (decl) = get_identifier (libname);
6815   make_function_rtl (decl);
6816
6817   /* Warn if a function in the namespace for users
6818      is used without an occasion to consider it declared.  */
6819   if (name[0] != '_' || name[1] != '_')
6820     DECL_ANTICIPATED (decl) = 1;
6821
6822   return decl;
6823 }
6824
6825 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
6826    function.  Not called directly.  */
6827
6828 static tree
6829 build_library_fn_1 (name, operator_code, type)
6830      tree name;
6831      enum tree_code operator_code;
6832      tree type;
6833 {
6834   tree fn = build_lang_decl (FUNCTION_DECL, name, type);
6835   DECL_EXTERNAL (fn) = 1;
6836   TREE_PUBLIC (fn) = 1;
6837   DECL_ARTIFICIAL (fn) = 1;
6838   TREE_NOTHROW (fn) = 1;
6839   SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
6840   return fn;
6841 }
6842
6843 /* Returns the _DECL for a library function with C linkage.
6844    We assume that such functions never throw; if this is incorrect,
6845    callers should unset TREE_NOTHROW.  */
6846
6847 tree
6848 build_library_fn (name, type)
6849      tree name;
6850      tree type;
6851 {
6852   tree fn = build_library_fn_1 (name, ERROR_MARK, type);
6853   make_function_rtl (fn);
6854   return fn;
6855 }
6856
6857 /* Returns the _DECL for a library function with C++ linkage.  */
6858
6859 static tree
6860 build_cp_library_fn (name, operator_code, type)
6861      tree name;
6862      enum tree_code operator_code;
6863      tree type;
6864 {
6865   tree fn = build_library_fn_1 (name, operator_code, type);
6866   TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
6867   DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
6868   set_mangled_name_for_decl (fn);
6869   make_function_rtl (fn);
6870   return fn;
6871 }
6872
6873 /* Like build_library_fn, but takes a C string instead of an
6874    IDENTIFIER_NODE.  */
6875
6876 tree
6877 build_library_fn_ptr (name, type)
6878      const char *name;
6879      tree type;
6880 {
6881   return build_library_fn (get_identifier (name), type);
6882 }
6883
6884 /* Like build_cp_library_fn, but takes a C string instead of an
6885    IDENTIFIER_NODE.  */
6886
6887 tree
6888 build_cp_library_fn_ptr (name, type)
6889      const char *name;
6890      tree type;
6891 {
6892   return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
6893 }
6894
6895 /* Like build_library_fn, but also pushes the function so that we will
6896    be able to find it via IDENTIFIER_GLOBAL_VALUE.  */
6897
6898 tree
6899 push_library_fn (name, type)
6900      tree name, type;
6901 {
6902   tree fn = build_library_fn (name, type);
6903   pushdecl_top_level (fn);
6904   return fn;
6905 }
6906
6907 /* Like build_cp_library_fn, but also pushes the function so that it
6908    will be found by normal lookup.  */
6909
6910 static tree
6911 push_cp_library_fn (operator_code, type)
6912      enum tree_code operator_code;
6913      tree type;
6914 {
6915   tree fn = build_cp_library_fn (ansi_opname (operator_code),
6916                                  operator_code,
6917                                  type);
6918   pushdecl (fn);
6919   return fn;
6920 }
6921
6922 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
6923    a FUNCTION_TYPE.  */
6924
6925 tree
6926 push_void_library_fn (name, parmtypes)
6927      tree name, parmtypes;
6928 {
6929   tree type = build_function_type (void_type_node, parmtypes);
6930   return push_library_fn (name, type);
6931 }
6932
6933 /* Like push_library_fn, but also note that this function throws
6934    and does not return.  Used for __throw_foo and the like.  */
6935
6936 tree
6937 push_throw_library_fn (name, type)
6938      tree name, type;
6939 {
6940   tree fn = push_library_fn (name, type);
6941   TREE_THIS_VOLATILE (fn) = 1;
6942   TREE_NOTHROW (fn) = 0;
6943   return fn;
6944 }
6945 \f
6946 /* When we call finish_struct for an anonymous union, we create
6947    default copy constructors and such.  But, an anonymous union
6948    shouldn't have such things; this function undoes the damage to the
6949    anonymous union type T.
6950
6951    (The reason that we create the synthesized methods is that we don't
6952    distinguish `union { int i; }' from `typedef union { int i; } U'.
6953    The first is an anonymous union; the second is just an ordinary
6954    union type.)  */
6955
6956 void
6957 fixup_anonymous_aggr (t)
6958      tree t;
6959 {
6960   tree *q;
6961
6962   /* Wipe out memory of synthesized methods */
6963   TYPE_HAS_CONSTRUCTOR (t) = 0;
6964   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6965   TYPE_HAS_INIT_REF (t) = 0;
6966   TYPE_HAS_CONST_INIT_REF (t) = 0;
6967   TYPE_HAS_ASSIGN_REF (t) = 0;
6968   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6969
6970   /* Splice the implicitly generated functions out of the TYPE_METHODS
6971      list.  */
6972   q = &TYPE_METHODS (t);
6973   while (*q)
6974     {
6975       if (DECL_ARTIFICIAL (*q))
6976         *q = TREE_CHAIN (*q);
6977       else
6978         q = &TREE_CHAIN (*q);
6979     }
6980
6981   /* ISO C++ 9.5.3.  Anonymous unions may not have function members.  */
6982   if (TYPE_METHODS (t))
6983     error ("an anonymous union cannot have function members");
6984 }
6985
6986 /* Make sure that a declaration with no declarator is well-formed, i.e.
6987    just defines a tagged type or anonymous union.
6988
6989    Returns the type defined, if any.  */
6990
6991 tree
6992 check_tag_decl (declspecs)
6993      tree declspecs;
6994 {
6995   int found_type = 0;
6996   int saw_friend = 0;
6997   tree ob_modifier = NULL_TREE;
6998   register tree link;
6999   register tree t = NULL_TREE;
7000
7001   for (link = declspecs; link; link = TREE_CHAIN (link))
7002     {
7003       register tree value = TREE_VALUE (link);
7004
7005       if (TYPE_P (value)
7006           || (TREE_CODE (value) == IDENTIFIER_NODE
7007               && IDENTIFIER_GLOBAL_VALUE (value)
7008               && TYPE_P (IDENTIFIER_GLOBAL_VALUE (value))))
7009         {
7010           ++found_type;
7011
7012           if (IS_AGGR_TYPE (value) || TREE_CODE (value) == ENUMERAL_TYPE)
7013             {
7014               my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
7015               t = value;
7016             }
7017         }
7018       else if (value == ridpointers[(int) RID_FRIEND])
7019         {
7020           if (current_class_type == NULL_TREE
7021               || current_scope () != current_class_type)
7022             ob_modifier = value;
7023           else
7024             saw_friend = 1;
7025         }
7026       else if (value == ridpointers[(int) RID_STATIC]
7027                || value == ridpointers[(int) RID_EXTERN]
7028                || value == ridpointers[(int) RID_AUTO]
7029                || value == ridpointers[(int) RID_REGISTER]
7030                || value == ridpointers[(int) RID_INLINE]
7031                || value == ridpointers[(int) RID_VIRTUAL]
7032                || value == ridpointers[(int) RID_CONST]
7033                || value == ridpointers[(int) RID_VOLATILE]
7034                || value == ridpointers[(int) RID_EXPLICIT])
7035         ob_modifier = value;
7036     }
7037
7038   if (found_type > 1)
7039     error ("multiple types in one declaration");
7040
7041   if (t == NULL_TREE && ! saw_friend)
7042     pedwarn ("declaration does not declare anything");
7043
7044   /* Check for an anonymous union.  We're careful
7045      accessing TYPE_IDENTIFIER because some built-in types, like
7046      pointer-to-member types, do not have TYPE_NAME.  */
7047   else if (t && IS_AGGR_TYPE_CODE (TREE_CODE (t))
7048            && TYPE_NAME (t)
7049            && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
7050     {
7051       /* Anonymous unions are objects, so they can have specifiers.  */;
7052       SET_ANON_AGGR_TYPE_P (t);
7053
7054       if (TREE_CODE (t) != UNION_TYPE && pedantic && ! in_system_header)
7055         pedwarn ("ISO C++ prohibits anonymous structs");
7056     }
7057
7058   else if (ob_modifier)
7059     {
7060       if (ob_modifier == ridpointers[(int) RID_INLINE]
7061           || ob_modifier == ridpointers[(int) RID_VIRTUAL])
7062         cp_error ("`%D' can only be specified for functions", ob_modifier);
7063       else if (ob_modifier == ridpointers[(int) RID_FRIEND])
7064         cp_error ("`%D' can only be specified inside a class", ob_modifier);
7065       else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
7066         cp_error ("`%D' can only be specified for constructors",
7067                   ob_modifier);
7068       else
7069         cp_error ("`%D' can only be specified for objects and functions",
7070                   ob_modifier);
7071     }
7072
7073   return t;
7074 }
7075
7076 /* Called when a declaration is seen that contains no names to declare.
7077    If its type is a reference to a structure, union or enum inherited
7078    from a containing scope, shadow that tag name for the current scope
7079    with a forward reference.
7080    If its type defines a new named structure or union
7081    or defines an enum, it is valid but we need not do anything here.
7082    Otherwise, it is an error.
7083
7084    C++: may have to grok the declspecs to learn about static,
7085    complain for anonymous unions.  */
7086
7087 void
7088 shadow_tag (declspecs)
7089      tree declspecs;
7090 {
7091   tree t = check_tag_decl (declspecs);
7092
7093   if (t)
7094     maybe_process_partial_specialization (t);
7095
7096   /* This is where the variables in an anonymous union are
7097      declared.  An anonymous union declaration looks like:
7098      union { ... } ;
7099      because there is no declarator after the union, the parser
7100      sends that declaration here.  */
7101   if (t && ANON_AGGR_TYPE_P (t))
7102     {
7103       fixup_anonymous_aggr (t);
7104
7105       if (TYPE_FIELDS (t))
7106         {
7107           tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
7108                                       NULL_TREE);
7109           finish_anon_union (decl);
7110         }
7111     }
7112 }
7113 \f
7114 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
7115
7116 tree
7117 groktypename (typename)
7118      tree typename;
7119 {
7120   if (TREE_CODE (typename) != TREE_LIST)
7121     return typename;
7122   return grokdeclarator (TREE_VALUE (typename),
7123                          TREE_PURPOSE (typename),
7124                          TYPENAME, 0, NULL_TREE);
7125 }
7126
7127 /* Decode a declarator in an ordinary declaration or data definition.
7128    This is called as soon as the type information and variable name
7129    have been parsed, before parsing the initializer if any.
7130    Here we create the ..._DECL node, fill in its type,
7131    and put it on the list of decls for the current context.
7132    The ..._DECL node is returned as the value.
7133
7134    Exception: for arrays where the length is not specified,
7135    the type is left null, to be filled in by `cp_finish_decl'.
7136
7137    Function definitions do not come here; they go to start_function
7138    instead.  However, external and forward declarations of functions
7139    do go through here.  Structure field declarations are done by
7140    grokfield and not through here.  */
7141
7142 tree
7143 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
7144      tree declarator, declspecs;
7145      int initialized;
7146      tree attributes, prefix_attributes;
7147 {
7148   register tree decl;
7149   register tree type, tem;
7150   tree context;
7151   extern int have_extern_spec;
7152   extern int used_extern_spec;
7153   tree attrlist;
7154
7155 #if 0
7156   /* See code below that used this.  */
7157   int init_written = initialized;
7158 #endif
7159
7160   /* This should only be done once on the top most decl.  */
7161   if (have_extern_spec && !used_extern_spec)
7162     {
7163       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"),
7164                                   declspecs);
7165       used_extern_spec = 1;
7166     }
7167
7168   if (attributes || prefix_attributes)
7169     attrlist = build_tree_list (attributes, prefix_attributes);
7170   else
7171     attrlist = NULL_TREE;
7172
7173   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
7174                          attrlist);
7175
7176   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
7177     return NULL_TREE;
7178
7179   type = TREE_TYPE (decl);
7180
7181   if (type == error_mark_node)
7182     return NULL_TREE;
7183
7184   context = DECL_CONTEXT (decl);
7185
7186   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
7187       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
7188     {
7189       /* When parsing the initializer, lookup should use the object's
7190          namespace. */
7191       push_decl_namespace (context);
7192     }
7193
7194   /* We are only interested in class contexts, later. */
7195   if (context && TREE_CODE (context) == NAMESPACE_DECL)
7196     context = NULL_TREE;
7197
7198   if (initialized)
7199     /* Is it valid for this decl to have an initializer at all?
7200        If not, set INITIALIZED to zero, which will indirectly
7201        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7202     switch (TREE_CODE (decl))
7203       {
7204       case TYPE_DECL:
7205         /* typedef foo = bar  means give foo the same type as bar.
7206            We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
7207            Any other case of an initialization in a TYPE_DECL is an error.  */
7208         if (pedantic || list_length (declspecs) > 1)
7209           {
7210             cp_error ("typedef `%D' is initialized", decl);
7211             initialized = 0;
7212           }
7213         break;
7214
7215       case FUNCTION_DECL:
7216         cp_error ("function `%#D' is initialized like a variable", decl);
7217         initialized = 0;
7218         break;
7219
7220       default:
7221         break;
7222       }
7223
7224   if (initialized)
7225     {
7226       if (! toplevel_bindings_p ()
7227           && DECL_EXTERNAL (decl))
7228         cp_warning ("declaration of `%#D' has `extern' and is initialized",
7229                     decl);
7230       DECL_EXTERNAL (decl) = 0;
7231       if (toplevel_bindings_p ())
7232         TREE_STATIC (decl) = 1;
7233
7234       /* Tell `pushdecl' this is an initialized decl
7235          even though we don't yet have the initializer expression.
7236          Also tell `cp_finish_decl' it may store the real initializer.  */
7237       DECL_INITIAL (decl) = error_mark_node;
7238     }
7239
7240 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
7241   SET_DEFAULT_DECL_ATTRIBUTES (decl, attributes);
7242 #endif
7243
7244   /* Set attributes here so if duplicate decl, will have proper attributes.  */
7245   cplus_decl_attributes (decl, attributes, prefix_attributes);
7246
7247   if (context && COMPLETE_TYPE_P (complete_type (context)))
7248     {
7249       push_nested_class (context, 2);
7250
7251       if (TREE_CODE (decl) == VAR_DECL)
7252         {
7253           tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
7254           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
7255             cp_error ("`%#D' is not a static member of `%#T'", decl, context);
7256           else
7257             {
7258               if (DECL_CONTEXT (field) != context)
7259                 {
7260                   cp_pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
7261                               DECL_CONTEXT (field), DECL_NAME (decl),
7262                               context, DECL_NAME (decl));
7263                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
7264                 }
7265               /* Static data member are tricky; an in-class initialization
7266                  still doesn't provide a definition, so the in-class
7267                  declaration will have DECL_EXTERNAL set, but will have an
7268                  initialization.  Thus, duplicate_decls won't warn
7269                  about this situation, and so we check here.  */
7270               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
7271                 cp_error ("duplicate initialization of %D", decl);
7272               if (duplicate_decls (decl, field))
7273                 decl = field;
7274             }
7275         }
7276       else
7277         {
7278           tree field = check_classfn (context, decl);
7279           if (field && duplicate_decls (decl, field))
7280             decl = field;
7281         }
7282
7283       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
7284       DECL_IN_AGGR_P (decl) = 0;
7285       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
7286           || CLASSTYPE_TEMPLATE_INSTANTIATION (context))
7287         {
7288           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
7289           /* [temp.expl.spec] An explicit specialization of a static data
7290              member of a template is a definition if the declaration
7291              includes an initializer; otherwise, it is a declaration.
7292
7293              We check for processing_specialization so this only applies
7294              to the new specialization syntax.  */
7295           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
7296             DECL_EXTERNAL (decl) = 1;
7297         }
7298
7299       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
7300         cp_pedwarn ("declaration of `%#D' outside of class is not definition",
7301                     decl);
7302     }
7303
7304   /* Enter this declaration into the symbol table.  */
7305   tem = maybe_push_decl (decl);
7306
7307   if (processing_template_decl)
7308     tem = push_template_decl (tem);
7309
7310 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7311   /* Tell the back-end to use or not use .common as appropriate.  If we say
7312      -fconserve-space, we want this to save .data space, at the expense of
7313      wrong semantics.  If we say -fno-conserve-space, we want this to
7314      produce errors about redefs; to do this we force variables into the
7315      data segment.  */
7316   DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
7317 #endif
7318
7319   if (! processing_template_decl)
7320     start_decl_1 (tem);
7321
7322   return tem;
7323 }
7324
7325 void
7326 start_decl_1 (decl)
7327      tree decl;
7328 {
7329   tree type = TREE_TYPE (decl);
7330   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
7331
7332   if (type == error_mark_node)
7333     return;
7334
7335   /* If this type of object needs a cleanup, but we're not allowed to
7336      add any more objects with cleanups to the current scope, create a
7337      new binding level.  */
7338   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
7339       && current_binding_level->more_cleanups_ok == 0)
7340     {
7341       keep_next_level (2);
7342       pushlevel (1);
7343       clear_last_expr ();
7344       add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
7345     }
7346
7347   if (initialized)
7348     /* Is it valid for this decl to have an initializer at all?
7349        If not, set INITIALIZED to zero, which will indirectly
7350        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7351     {
7352       /* Don't allow initializations for incomplete types except for
7353          arrays which might be completed by the initialization.  */
7354       if (COMPLETE_TYPE_P (complete_type (type)))
7355         ;                       /* A complete type is ok.  */
7356       else if (TREE_CODE (type) != ARRAY_TYPE)
7357         {
7358           cp_error ("variable `%#D' has initializer but incomplete type",
7359                     decl);
7360           initialized = 0;
7361           type = TREE_TYPE (decl) = error_mark_node;
7362         }
7363       else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7364         {
7365           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
7366             cp_error ("elements of array `%#D' have incomplete type", decl);
7367           /* else we already gave an error in start_decl.  */
7368           initialized = 0;
7369         }
7370     }
7371
7372   if (!initialized
7373       && TREE_CODE (decl) != TYPE_DECL
7374       && TREE_CODE (decl) != TEMPLATE_DECL
7375       && type != error_mark_node
7376       && IS_AGGR_TYPE (type)
7377       && ! DECL_EXTERNAL (decl))
7378     {
7379       if ((! processing_template_decl || ! uses_template_parms (type))
7380           && !COMPLETE_TYPE_P (complete_type (type)))
7381         {
7382           cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
7383                  decl);
7384           /* Change the type so that assemble_variable will give
7385              DECL an rtl we can live with: (mem (const_int 0)).  */
7386           type = TREE_TYPE (decl) = error_mark_node;
7387         }
7388       else
7389         {
7390           /* If any base type in the hierarchy of TYPE needs a constructor,
7391              then we set initialized to 1.  This way any nodes which are
7392              created for the purposes of initializing this aggregate
7393              will live as long as it does.  This is necessary for global
7394              aggregates which do not have their initializers processed until
7395              the end of the file.  */
7396           initialized = TYPE_NEEDS_CONSTRUCTING (type);
7397         }
7398     }
7399
7400   if (! initialized)
7401     DECL_INITIAL (decl) = NULL_TREE;
7402 }
7403
7404 /* Handle initialization of references.
7405    These three arguments are from `cp_finish_decl', and have the
7406    same meaning here that they do there.
7407
7408    Quotes on semantics can be found in ARM 8.4.3.  */
7409
7410 static void
7411 grok_reference_init (decl, type, init)
7412      tree decl, type, init;
7413 {
7414   tree tmp;
7415
7416   if (init == NULL_TREE)
7417     {
7418       if ((DECL_LANG_SPECIFIC (decl) == 0
7419            || DECL_IN_AGGR_P (decl) == 0)
7420           && ! DECL_THIS_EXTERN (decl))
7421         cp_error ("`%D' declared as reference but not initialized", decl);
7422       return;
7423     }
7424
7425   if (init == error_mark_node)
7426     return;
7427
7428   if (TREE_CODE (init) == CONSTRUCTOR)
7429     {
7430       cp_error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
7431       return;
7432     }
7433
7434   if (TREE_CODE (init) == TREE_LIST)
7435     init = build_compound_expr (init);
7436
7437   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
7438     init = convert_from_reference (init);
7439
7440   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
7441       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
7442     {
7443       /* Note: default conversion is only called in very special cases.  */
7444       init = default_conversion (init);
7445     }
7446
7447   /* Convert INIT to the reference type TYPE.  This may involve the
7448      creation of a temporary, whose lifetime must be the same as that
7449      of the reference.  If so, a DECL_STMT for the temporary will be
7450      added just after the DECL_STMT for DECL.  That's why we don't set
7451      DECL_INITIAL for local references (instead assigning to them
7452      explicitly); we need to allow the temporary to be initialized
7453      first.  */
7454   tmp = convert_to_reference
7455     (type, init, CONV_IMPLICIT,
7456      LOOKUP_ONLYCONVERTING|LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND,
7457      decl);
7458
7459   if (tmp == error_mark_node)
7460     return;
7461   else if (tmp != NULL_TREE)
7462     {
7463       init = tmp;
7464       tmp = save_expr (tmp);
7465       if (building_stmt_tree ())
7466         {
7467           /* Initialize the declaration.  */
7468           tmp = build (INIT_EXPR, TREE_TYPE (decl), decl, tmp);
7469           finish_expr_stmt (tmp);
7470         }
7471       else
7472         DECL_INITIAL (decl) = tmp;
7473     }
7474   else
7475     {
7476       cp_error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
7477       return;
7478     }
7479
7480   if (TREE_STATIC (decl) && ! TREE_CONSTANT (DECL_INITIAL (decl)))
7481     {
7482       expand_static_init (decl, DECL_INITIAL (decl));
7483       DECL_INITIAL (decl) = NULL_TREE;
7484     }
7485   return;
7486 }
7487
7488 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7489    mucking with forces it does not comprehend (i.e. initialization with a
7490    constructor).  If we are at global scope and won't go into COMMON, fill
7491    it in with a dummy CONSTRUCTOR to force the variable into .data;
7492    otherwise we can use error_mark_node.  */
7493
7494 static tree
7495 obscure_complex_init (decl, init)
7496      tree decl, init;
7497 {
7498   if (! flag_no_inline && TREE_STATIC (decl))
7499     {
7500       if (extract_init (decl, init))
7501         return NULL_TREE;
7502     }
7503
7504 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7505   if (toplevel_bindings_p () && ! DECL_COMMON (decl))
7506     DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
7507                                  NULL_TREE);
7508   else
7509 #endif
7510     DECL_INITIAL (decl) = error_mark_node;
7511
7512   return init;
7513 }
7514
7515 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7516    array until we finish parsing the initializer.  If that's the
7517    situation we're in, update DECL accordingly.  */
7518
7519 static void
7520 maybe_deduce_size_from_array_init (decl, init)
7521      tree decl;
7522      tree init;
7523 {
7524   tree type = TREE_TYPE (decl);
7525
7526   if (TREE_CODE (type) == ARRAY_TYPE
7527       && TYPE_DOMAIN (type) == NULL_TREE
7528       && TREE_CODE (decl) != TYPE_DECL)
7529     {
7530       int do_default
7531         = (TREE_STATIC (decl)
7532            /* Even if pedantic, an external linkage array
7533               may have incomplete type at first.  */
7534            ? pedantic && ! DECL_EXTERNAL (decl)
7535            : !DECL_EXTERNAL (decl));
7536       tree initializer = init ? init : DECL_INITIAL (decl);
7537       int failure = complete_array_type (type, initializer, do_default);
7538
7539       if (failure == 1)
7540         cp_error ("initializer fails to determine size of `%D'", decl);
7541
7542       if (failure == 2)
7543         {
7544           if (do_default)
7545             cp_error ("array size missing in `%D'", decl);
7546           /* If a `static' var's size isn't known, make it extern as
7547              well as static, so it does not get allocated.  If it's not
7548              `static', then don't mark it extern; finish_incomplete_decl
7549              will give it a default size and it will get allocated.  */
7550           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7551             DECL_EXTERNAL (decl) = 1;
7552         }
7553
7554       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7555           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7556                               integer_zero_node))
7557         cp_error ("zero-size array `%D'", decl);
7558
7559       layout_decl (decl, 0);
7560     }
7561 }
7562
7563 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7564    any appropriate error messages regarding the layout.  */
7565
7566 static void
7567 layout_var_decl (decl)
7568      tree decl;
7569 {
7570   tree type = TREE_TYPE (decl);
7571 #if 0
7572   tree ttype = target_type (type);
7573 #endif
7574
7575   /* If we haven't already layed out this declaration, do so now.
7576      Note that we must not call complete type for an external object
7577      because it's type might involve templates that we are not
7578      supposed to isntantiate yet.  (And it's perfectly legal to say
7579      `extern X x' for some incomplete type `X'.)  */
7580   if (!DECL_EXTERNAL (decl))
7581     complete_type (type);
7582   if (!DECL_SIZE (decl) && COMPLETE_TYPE_P (type))
7583     layout_decl (decl, 0);
7584
7585   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7586     {
7587       /* An automatic variable with an incomplete type: that is an error.
7588          Don't talk about array types here, since we took care of that
7589          message in grokdeclarator.  */
7590       cp_error ("storage size of `%D' isn't known", decl);
7591       TREE_TYPE (decl) = error_mark_node;
7592     }
7593 #if 0
7594   /* Keep this code around in case we later want to control debug info
7595      based on whether a type is "used".  (jason 1999-11-11) */
7596
7597   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7598     /* Let debugger know it should output info for this type.  */
7599     note_debug_info_needed (ttype);
7600
7601   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7602     note_debug_info_needed (DECL_CONTEXT (decl));
7603 #endif
7604
7605   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7606       && DECL_SIZE (decl) != NULL_TREE
7607       && ! TREE_CONSTANT (DECL_SIZE (decl)))
7608     {
7609       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7610         constant_expression_warning (DECL_SIZE (decl));
7611       else
7612         cp_error ("storage size of `%D' isn't constant", decl);
7613     }
7614 }
7615
7616 /* If a local static variable is declared in an inline function, or if
7617    we have a weak definition, we must endeavor to create only one
7618    instance of the variable at link-time.  */
7619
7620 static void
7621 maybe_commonize_var (decl)
7622      tree decl;
7623 {
7624   /* Static data in a function with comdat linkage also has comdat
7625      linkage.  */
7626   if (TREE_STATIC (decl)
7627       /* Don't mess with __FUNCTION__.  */
7628       && ! DECL_ARTIFICIAL (decl)
7629       && current_function_decl
7630       && DECL_CONTEXT (decl) == current_function_decl
7631       && (DECL_THIS_INLINE (current_function_decl)
7632           || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7633       && TREE_PUBLIC (current_function_decl))
7634     {
7635       /* Rather than try to get this right with inlining, we suppress
7636          inlining of such functions.  */
7637       current_function_cannot_inline
7638         = "function with static variable cannot be inline";
7639
7640       /* If flag_weak, we don't need to mess with this, as we can just
7641          make the function weak, and let it refer to its unique local
7642          copy.  This works because we don't allow the function to be
7643          inlined.  */
7644       if (! flag_weak)
7645         {
7646           if (DECL_INTERFACE_KNOWN (current_function_decl))
7647             {
7648               TREE_PUBLIC (decl) = 1;
7649               DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7650             }
7651           else if (DECL_INITIAL (decl) == NULL_TREE
7652                    || DECL_INITIAL (decl) == error_mark_node)
7653             {
7654               TREE_PUBLIC (decl) = 1;
7655               DECL_COMMON (decl) = 1;
7656             }
7657           /* else we lose. We can only do this if we can use common,
7658              which we can't if it has been initialized.  */
7659
7660           if (TREE_PUBLIC (decl))
7661             DECL_ASSEMBLER_NAME (decl)
7662               = build_static_name (current_function_decl, DECL_NAME (decl));
7663           else
7664             {
7665               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7666               cp_warning_at ("  you can work around this by removing the initializer", decl);
7667             }
7668         }
7669     }
7670   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7671     /* Set it up again; we might have set DECL_INITIAL since the last
7672        time.  */
7673     comdat_linkage (decl);
7674 }
7675
7676 /* Issue an error message if DECL is an uninitialized const variable.  */
7677
7678 static void
7679 check_for_uninitialized_const_var (decl)
7680      tree decl;
7681 {
7682   tree type = TREE_TYPE (decl);
7683
7684   /* ``Unless explicitly declared extern, a const object does not have
7685      external linkage and must be initialized. ($8.4; $12.1)'' ARM
7686      7.1.6 */
7687   if (TREE_CODE (decl) == VAR_DECL
7688       && TREE_CODE (type) != REFERENCE_TYPE
7689       && CP_TYPE_CONST_P (type)
7690       && !TYPE_NEEDS_CONSTRUCTING (type)
7691       && !DECL_INITIAL (decl))
7692     cp_error ("uninitialized const `%D'", decl);
7693 }
7694
7695 /* Verify INIT (the initializer for DECL), and record the
7696    initialization in DECL_INITIAL, if appropriate.  Returns a new
7697    value for INIT.  */
7698
7699 static tree
7700 check_initializer (decl, init)
7701      tree decl;
7702      tree init;
7703 {
7704   tree type;
7705
7706   if (TREE_CODE (decl) == FIELD_DECL)
7707     return init;
7708
7709   type = TREE_TYPE (decl);
7710
7711   /* If `start_decl' didn't like having an initialization, ignore it now.  */
7712   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7713     init = NULL_TREE;
7714
7715   /* Check the initializer.  */
7716   if (init)
7717     {
7718       /* Things that are going to be initialized need to have complete
7719          type.  */
7720       TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7721
7722       if (type == error_mark_node)
7723         /* We will have already complained.  */
7724         init = NULL_TREE;
7725       else if (COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
7726         {
7727           cp_error ("variable-sized object `%D' may not be initialized", decl);
7728           init = NULL_TREE;
7729         }
7730       else if (TREE_CODE (type) == ARRAY_TYPE
7731                && !COMPLETE_TYPE_P (TREE_TYPE (type)))
7732         {
7733           cp_error ("elements of array `%#D' have incomplete type", decl);
7734           init = NULL_TREE;
7735         }
7736       else if (!COMPLETE_TYPE_P (type))
7737         {
7738           cp_error ("`%D' has incomplete type", decl);
7739           TREE_TYPE (decl) = error_mark_node;
7740           init = NULL_TREE;
7741         }
7742     }
7743
7744   if (TREE_CODE (decl) == CONST_DECL)
7745     {
7746       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7747
7748       DECL_INITIAL (decl) = init;
7749
7750       /* This will keep us from needing to worry about our obstacks.  */
7751       my_friendly_assert (init != NULL_TREE, 149);
7752       init = NULL_TREE;
7753     }
7754   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7755     {
7756       if (TREE_STATIC (decl))
7757         make_decl_rtl (decl, NULL_PTR, toplevel_bindings_p ());
7758       grok_reference_init (decl, type, init);
7759       init = NULL_TREE;
7760     }
7761   else if (init)
7762     {
7763       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7764         {
7765           if (TREE_CODE (type) == ARRAY_TYPE)
7766             init = digest_init (type, init, (tree *) 0);
7767           else if (TREE_CODE (init) == CONSTRUCTOR
7768                    && TREE_HAS_CONSTRUCTOR (init))
7769             {
7770               if (TYPE_NON_AGGREGATE_CLASS (type))
7771                 {
7772                   cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7773                             decl);
7774                   init = error_mark_node;
7775                 }
7776               else
7777                 goto dont_use_constructor;
7778             }
7779         }
7780       else
7781         {
7782         dont_use_constructor:
7783           if (TREE_CODE (init) != TREE_VEC)
7784             init = store_init_value (decl, init);
7785         }
7786
7787       if (init)
7788         /* We must hide the initializer so that expand_decl
7789            won't try to do something it does not understand.  */
7790         init = obscure_complex_init (decl, init);
7791     }
7792   else if (DECL_EXTERNAL (decl))
7793     ;
7794   else if (TYPE_P (type)
7795            && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
7796     {
7797       tree core_type = strip_array_types (type);
7798
7799       if (! TYPE_NEEDS_CONSTRUCTING (core_type))
7800         {
7801           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
7802             cp_error ("structure `%D' with uninitialized const members", decl);
7803           if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
7804             cp_error ("structure `%D' with uninitialized reference members",
7805                       decl);
7806         }
7807
7808       check_for_uninitialized_const_var (decl);
7809
7810       if (COMPLETE_TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
7811         init = obscure_complex_init (decl, NULL_TREE);
7812
7813     }
7814   else
7815     check_for_uninitialized_const_var (decl);
7816
7817   return init;
7818 }
7819
7820 /* If DECL is not a local variable, give it RTL.  */
7821
7822 static void
7823 make_rtl_for_nonlocal_decl (decl, init, asmspec)
7824      tree decl;
7825      tree init;
7826      const char *asmspec;
7827 {
7828   int toplev;
7829   tree type;
7830
7831   type = TREE_TYPE (decl);
7832   toplev = toplevel_bindings_p ();
7833
7834   /* Handle non-variables up front.  */
7835   if (TREE_CODE (decl) != VAR_DECL)
7836     {
7837       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7838       return;
7839     }
7840
7841   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
7842   if (asmspec)
7843     DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
7844
7845   if (DECL_VIRTUAL_P (decl))
7846     make_decl_rtl (decl, NULL_PTR, toplev);
7847   else if (TREE_READONLY (decl)
7848            && DECL_INITIAL (decl) != NULL_TREE
7849            && DECL_INITIAL (decl) != error_mark_node
7850            && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl)))
7851     {
7852       DECL_INITIAL (decl) = save_expr (DECL_INITIAL (decl));
7853
7854       if (toplev && ! TREE_PUBLIC (decl))
7855         {
7856           /* If this is a static const, change its apparent linkage
7857              if it belongs to a #pragma interface.  */
7858           if (!interface_unknown)
7859             {
7860               TREE_PUBLIC (decl) = 1;
7861               DECL_EXTERNAL (decl) = interface_only;
7862             }
7863           make_decl_rtl (decl, asmspec, toplev);
7864         }
7865       else if (toplev)
7866         rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7867     }
7868   else if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
7869     {
7870       my_friendly_assert (TREE_STATIC (decl), 19990828);
7871
7872       if (init == NULL_TREE
7873 #ifdef DEFAULT_STATIC_DEFS
7874           /* If this code is dead, then users must
7875              explicitly declare static member variables
7876              outside the class def'n as well.  */
7877           && TYPE_NEEDS_CONSTRUCTING (type)
7878 #endif
7879           )
7880         {
7881           DECL_EXTERNAL (decl) = 1;
7882           make_decl_rtl (decl, asmspec, 1);
7883         }
7884       else
7885         rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7886     }
7887   else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == NAMESPACE_DECL
7888            || (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl)))
7889     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7890 }
7891
7892
7893 /* The old ARM scoping rules injected variables declared in the
7894    initialization statement of a for-statement into the surrounding
7895    scope.  We support this usage, in order to be backward-compatible.
7896    DECL is a just-declared VAR_DECL; if necessary inject its
7897    declaration into the surrounding scope.  */
7898
7899 void
7900 maybe_inject_for_scope_var (decl)
7901      tree decl;
7902 {
7903   if (current_binding_level->is_for_scope)
7904     {
7905       struct binding_level *outer
7906         = current_binding_level->level_chain;
7907
7908       /* Check to see if the same name is already bound at the outer
7909          level, either because it was directly declared, or because a
7910          dead for-decl got preserved.  In either case, the code would
7911          not have been valid under the ARM scope rules, so clear
7912          is_for_scope for the current_binding_level.
7913
7914          Otherwise, we need to preserve the temp slot for decl to last
7915          into the outer binding level.  */
7916
7917       tree outer_binding
7918         = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
7919
7920       if (outer_binding && BINDING_LEVEL (outer_binding) == outer
7921           && (TREE_CODE (BINDING_VALUE (outer_binding))
7922               == VAR_DECL)
7923           && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
7924         {
7925           BINDING_VALUE (outer_binding)
7926             = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
7927           current_binding_level->is_for_scope = 0;
7928         }
7929       else if (DECL_IN_MEMORY_P (decl))
7930         preserve_temp_slots (DECL_RTL (decl));
7931     }
7932 }
7933
7934 /* Generate code to initialize DECL (a local variable).  */
7935
7936 void
7937 initialize_local_var (decl, init, flags)
7938      tree decl;
7939      tree init;
7940      int flags;
7941 {
7942   tree type = TREE_TYPE (decl);
7943
7944   /* If the type is bogus, don't bother initializing the variable.  */
7945   if (type == error_mark_node)
7946     return;
7947
7948   if (DECL_SIZE (decl) == NULL_TREE && !TREE_STATIC (decl))
7949     {
7950       /* If we used it already as memory, it must stay in memory.  */
7951       DECL_INITIAL (decl) = NULL_TREE;
7952       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
7953     }
7954
7955   /* Local statics are handled differently from ordinary automatic
7956      variables.  */
7957   if (TREE_STATIC (decl))
7958     {
7959       if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7960           || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7961         expand_static_init (decl, init);
7962       return;
7963     }
7964
7965   if (DECL_SIZE (decl) && type != error_mark_node)
7966     {
7967       int already_used;
7968
7969       /* Compute and store the initial value.  */
7970       already_used = TREE_USED (decl) || TREE_USED (type);
7971
7972       if (init || TYPE_NEEDS_CONSTRUCTING (type))
7973         {
7974           int saved_stmts_are_full_exprs_p;
7975
7976           emit_line_note (DECL_SOURCE_FILE (decl),
7977                           DECL_SOURCE_LINE (decl));
7978           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
7979           current_stmt_tree->stmts_are_full_exprs_p = 1;
7980           if (building_stmt_tree ())
7981             finish_expr_stmt (build_aggr_init (decl, init, flags));
7982           else
7983             genrtl_expr_stmt (build_aggr_init (decl, init, flags));
7984           current_stmt_tree->stmts_are_full_exprs_p = saved_stmts_are_full_exprs_p;
7985         }
7986
7987       /* Set this to 0 so we can tell whether an aggregate which was
7988          initialized was ever used.  Don't do this if it has a
7989          destructor, so we don't complain about the 'resource
7990          allocation is initialization' idiom.  Now set
7991          attribute((unused)) on types so decls of that type will be
7992          marked used. (see TREE_USED, above.)  */
7993       if (TYPE_NEEDS_CONSTRUCTING (type)
7994           && ! already_used
7995           && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
7996           && DECL_NAME (decl))
7997         TREE_USED (decl) = 0;
7998       else if (already_used)
7999         TREE_USED (decl) = 1;
8000     }
8001 }
8002
8003 /* Generate code to destroy DECL (a local variable).  */
8004
8005 static void
8006 destroy_local_var (decl)
8007      tree decl;
8008 {
8009   tree type = TREE_TYPE (decl);
8010   tree cleanup;
8011
8012   /* Only variables get cleaned up.  */
8013   if (TREE_CODE (decl) != VAR_DECL)
8014     return;
8015
8016   /* And only things with destructors need cleaning up.  */
8017   if (type == error_mark_node
8018       || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
8019     return;
8020
8021   if (TREE_CODE (decl) == VAR_DECL &&
8022       (DECL_EXTERNAL (decl) || TREE_STATIC (decl)))
8023     /* We don't clean up things that aren't defined in this
8024        translation unit, or that need a static cleanup.  The latter
8025        are handled by finish_file.  */
8026     return;
8027
8028   /* Compute the cleanup.  */
8029   cleanup = maybe_build_cleanup (decl);
8030
8031   /* Record the cleanup required for this declaration.  */
8032   if (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node
8033       && cleanup)
8034     finish_decl_cleanup (decl, cleanup);
8035 }
8036
8037
8038 /* Finish processing of a declaration;
8039    install its line number and initial value.
8040    If the length of an array type is not known before,
8041    it must be determined now, from the initial value, or it is an error.
8042
8043    INIT0 holds the value of an initializer that should be allowed to escape
8044    the normal rules.
8045
8046    FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
8047    if the (init) syntax was used.  */
8048
8049 void
8050 cp_finish_decl (decl, init, asmspec_tree, flags)
8051      tree decl, init;
8052      tree asmspec_tree;
8053      int flags;
8054 {
8055   register tree type;
8056   tree ttype = NULL_TREE;
8057   const char *asmspec = NULL;
8058   int was_readonly = 0;
8059
8060   if (! decl)
8061     {
8062       if (init)
8063         error ("assignment (not initialization) in declaration");
8064       return;
8065     }
8066
8067   /* If a name was specified, get the string.  */
8068   if (asmspec_tree)
8069       asmspec = TREE_STRING_POINTER (asmspec_tree);
8070
8071   if (init && TREE_CODE (init) == NAMESPACE_DECL)
8072     {
8073       cp_error ("cannot initialize `%D' to namespace `%D'",
8074                 decl, init);
8075       init = NULL_TREE;
8076     }
8077
8078   if (current_class_type
8079       && CP_DECL_CONTEXT (decl) == current_class_type
8080       && TYPE_BEING_DEFINED (current_class_type)
8081       && (DECL_INITIAL (decl) || init))
8082     DECL_DEFINED_IN_CLASS_P (decl) = 1;
8083
8084   if (TREE_CODE (decl) == VAR_DECL
8085       && DECL_CONTEXT (decl)
8086       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
8087       && DECL_CONTEXT (decl) != current_namespace
8088       && init)
8089     {
8090       /* Leave the namespace of the object. */
8091       pop_decl_namespace ();
8092     }
8093
8094   type = TREE_TYPE (decl);
8095
8096   if (type == error_mark_node)
8097     return;
8098
8099   /* Add this declaration to the statement-tree.  */
8100   if (building_stmt_tree () && at_function_scope_p ())
8101     add_decl_stmt (decl);
8102
8103   if (TYPE_HAS_MUTABLE_P (type))
8104     TREE_READONLY (decl) = 0;
8105
8106   if (processing_template_decl)
8107     {
8108       if (init && DECL_INITIAL (decl))
8109         DECL_INITIAL (decl) = init;
8110       goto finish_end0;
8111     }
8112
8113   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
8114   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
8115
8116   /* Take care of TYPE_DECLs up front.  */
8117   if (TREE_CODE (decl) == TYPE_DECL)
8118     {
8119       if (init && DECL_INITIAL (decl))
8120         {
8121           /* typedef foo = bar; store the type of bar as the type of foo.  */
8122           TREE_TYPE (decl) = type = TREE_TYPE (init);
8123           DECL_INITIAL (decl) = init = NULL_TREE;
8124         }
8125       if (type != error_mark_node
8126           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
8127         {
8128           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
8129             cp_warning ("shadowing previous type declaration of `%#D'", decl);
8130           set_identifier_type_value (DECL_NAME (decl), type);
8131           CLASSTYPE_GOT_SEMICOLON (type) = 1;
8132         }
8133       GNU_xref_decl (current_function_decl, decl);
8134
8135       /* If we have installed this as the canonical typedef for this
8136          type, and that type has not been defined yet, delay emitting
8137          the debug information for it, as we will emit it later.  */
8138       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
8139           && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
8140         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
8141
8142       rest_of_decl_compilation (decl, NULL_PTR,
8143                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
8144       goto finish_end;
8145     }
8146
8147   if (TREE_CODE (decl) != FUNCTION_DECL)
8148     ttype = target_type (type);
8149
8150   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
8151       && TYPE_NEEDS_CONSTRUCTING (type))
8152     {
8153       /* Currently, GNU C++ puts constants in text space, making them
8154          impossible to initialize.  In the future, one would hope for
8155          an operating system which understood the difference between
8156          initialization and the running of a program.  */
8157       was_readonly = 1;
8158       TREE_READONLY (decl) = 0;
8159     }
8160
8161   if (TREE_CODE (decl) == FIELD_DECL && asmspec)
8162     {
8163       /* This must override the asm specifier which was placed by
8164          grokclassfn.  Lay this out fresh.  */
8165       DECL_RTL (TREE_TYPE (decl)) = NULL_RTX;
8166       DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
8167       make_decl_rtl (decl, asmspec, 0);
8168     }
8169
8170   /* Deduce size of array from initialization, if not already known.  */
8171   maybe_deduce_size_from_array_init (decl, init);
8172   init = check_initializer (decl, init);
8173
8174   GNU_xref_decl (current_function_decl, decl);
8175
8176   if (TREE_CODE (decl) == VAR_DECL)
8177     layout_var_decl (decl);
8178
8179   /* Output the assembler code and/or RTL code for variables and functions,
8180      unless the type is an undefined structure or union.
8181      If not, it will get done when the type is completed.  */
8182   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
8183       || TREE_CODE (decl) == RESULT_DECL)
8184     {
8185       if (TREE_CODE (decl) == VAR_DECL)
8186         maybe_commonize_var (decl);
8187
8188       make_rtl_for_nonlocal_decl (decl, init, asmspec);
8189
8190       if (TREE_CODE (type) == FUNCTION_TYPE
8191           || TREE_CODE (type) == METHOD_TYPE)
8192         abstract_virtuals_error (decl,
8193                                  strip_array_types (TREE_TYPE (type)));
8194       else
8195         abstract_virtuals_error (decl, strip_array_types (type));
8196
8197       if (TREE_CODE (decl) == FUNCTION_DECL)
8198         ;
8199       else if (DECL_EXTERNAL (decl)
8200                && ! (DECL_LANG_SPECIFIC (decl)
8201                      && DECL_NOT_REALLY_EXTERN (decl)))
8202         {
8203           if (init)
8204             DECL_INITIAL (decl) = init;
8205         }
8206       else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
8207         {
8208           /* This is a local declaration.  */
8209           if (doing_semantic_analysis_p ())
8210             maybe_inject_for_scope_var (decl);
8211           /* Initialize the local variable.  But, if we're building a
8212              statement-tree, we'll do the initialization when we
8213              expand the tree.  */
8214           if (processing_template_decl)
8215             {
8216               if (init || DECL_INITIAL (decl) == error_mark_node)
8217                 DECL_INITIAL (decl) = init;
8218             }
8219           else
8220             {
8221               /* If we're not building RTL, then we need to do so
8222                  now.  */
8223               if (!building_stmt_tree ())
8224                 emit_local_var (decl);
8225               /* Initialize the variable.  */
8226               initialize_local_var (decl, init, flags);
8227               /* Clean up the variable.  */
8228               destroy_local_var (decl);
8229             }
8230         }
8231       else if (TREE_STATIC (decl) && type != error_mark_node)
8232         {
8233           /* Cleanups for static variables are handled by `finish_file'.  */
8234           if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
8235               || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8236             expand_static_init (decl, init);
8237         }
8238     finish_end0:
8239
8240       /* Undo call to `pushclass' that was done in `start_decl'
8241          due to initialization of qualified member variable.
8242          I.e., Foo::x = 10;  */
8243       {
8244         tree context = CP_DECL_CONTEXT (decl);
8245         if (context
8246             && TYPE_P (context)
8247             && (TREE_CODE (decl) == VAR_DECL
8248                 /* We also have a pushclass done that we need to undo here
8249                    if we're at top level and declare a method.  */
8250                 || TREE_CODE (decl) == FUNCTION_DECL)
8251             /* If size hasn't been set, we're still defining it,
8252                and therefore inside the class body; don't pop
8253                the binding level..  */
8254             && COMPLETE_TYPE_P (context)
8255             && context == current_class_type)
8256           pop_nested_class ();
8257       }
8258     }
8259
8260  finish_end:
8261
8262   if (was_readonly)
8263     TREE_READONLY (decl) = 1;
8264 }
8265
8266 /* This is here for a midend callback from c-common.c */
8267
8268 void
8269 finish_decl (decl, init, asmspec_tree)
8270      tree decl, init;
8271      tree asmspec_tree;
8272 {
8273   cp_finish_decl (decl, init, asmspec_tree, 0);
8274 }
8275
8276 /* Returns a declaration for a VAR_DECL as if:
8277
8278      extern "C" TYPE NAME;
8279
8280    had been seen.  Used to create compiler-generated global
8281    variables.  */
8282
8283 tree
8284 declare_global_var (name, type)
8285      tree name;
8286      tree type;
8287 {
8288   tree decl;
8289
8290   push_to_top_level ();
8291   decl = build_decl (VAR_DECL, name, type);
8292   TREE_PUBLIC (decl) = 1;
8293   DECL_EXTERNAL (decl) = 1;
8294   DECL_ARTIFICIAL (decl) = 1;
8295   pushdecl (decl);
8296   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
8297   pop_from_top_level ();
8298
8299   return decl;
8300 }
8301
8302 /* Returns a pointer to the `atexit' function.  Note that if
8303    FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
8304    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
8305
8306 static tree
8307 get_atexit_node ()
8308 {
8309   tree atexit_fndecl;
8310   tree arg_types;
8311   tree fn_type;
8312   tree fn_ptr_type;
8313   const char *name;
8314
8315   if (atexit_node)
8316     return atexit_node;
8317
8318   if (flag_use_cxa_atexit)
8319     {
8320       /* The declaration for `__cxa_atexit' is:
8321
8322            int __cxa_atexit (void (*)(void *), void *, void *)
8323
8324          We build up the argument types and then then function type
8325          itself.  */
8326
8327       /* First, build the pointer-to-function type for the first
8328          argument.  */
8329       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8330       fn_type = build_function_type (void_type_node, arg_types);
8331       fn_ptr_type = build_pointer_type (fn_type);
8332       /* Then, build the rest of the argument types.  */
8333       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8334       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
8335       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
8336       /* And the final __cxa_atexit type.  */
8337       fn_type = build_function_type (integer_type_node, arg_types);
8338       fn_ptr_type = build_pointer_type (fn_type);
8339       name = "__cxa_atexit";
8340     }
8341   else
8342     {
8343       /* The declaration for `atexit' is:
8344
8345            int atexit (void (*)());
8346
8347          We build up the argument types and then then function type
8348          itself.  */
8349       fn_type = build_function_type (void_type_node, void_list_node);
8350       fn_ptr_type = build_pointer_type (fn_type);
8351       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
8352       /* Build the final atexit type.  */
8353       fn_type = build_function_type (integer_type_node, arg_types);
8354       name = "atexit";
8355     }
8356
8357   /* Now, build the function declaration.  */
8358   push_lang_context (lang_name_c);
8359   atexit_fndecl = build_library_fn_ptr (name, fn_type);
8360   mark_used (atexit_fndecl);
8361   pop_lang_context ();
8362   atexit_node = default_conversion (atexit_fndecl);
8363
8364   return atexit_node;
8365 }
8366
8367 /* Returns the __dso_handle VAR_DECL.  */
8368
8369 static tree
8370 get_dso_handle_node ()
8371 {
8372   if (dso_handle_node)
8373     return dso_handle_node;
8374
8375   /* Declare the variable.  */
8376   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8377                                         ptr_type_node);
8378
8379   return dso_handle_node;
8380 }
8381
8382 /* Begin a new function with internal linkage whose job will be simply
8383    to destroy some particular variable.  */
8384
8385 static tree
8386 start_cleanup_fn ()
8387 {
8388   static int counter = 0;
8389   int old_interface_unknown = interface_unknown;
8390   char name[32];
8391   tree parmtypes;
8392   tree fntype;
8393   tree fndecl;
8394
8395   push_to_top_level ();
8396
8397   /* No need to mangle this.  */
8398   push_lang_context (lang_name_c);
8399
8400   interface_unknown = 1;
8401
8402   /* Build the parameter-types.  */
8403   parmtypes = void_list_node;
8404   /* Functions passed to __cxa_atexit take an additional parameter.
8405      We'll just ignore it.  After we implement the new calling
8406      convention for destructors, we can eliminate the use of
8407      additional cleanup functions entirely in the -fnew-abi case.  */
8408   if (flag_use_cxa_atexit)
8409     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8410   /* Build the function type itself.  */
8411   fntype = build_function_type (void_type_node, parmtypes);
8412   /* Build the name of the function.  */
8413   sprintf (name, "__tcf_%d", counter++);
8414   /* Build the function declaration.  */
8415   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8416   /* It's a function with internal linkage, generated by the
8417      compiler.  */
8418   TREE_PUBLIC (fndecl) = 0;
8419   DECL_ARTIFICIAL (fndecl) = 1;
8420   /* Build the parameter.  */
8421   if (flag_use_cxa_atexit)
8422     {
8423       tree parmdecl;
8424
8425       parmdecl = build_decl (PARM_DECL, NULL_TREE, ptr_type_node);
8426       DECL_CONTEXT (parmdecl) = fndecl;
8427       DECL_ARG_TYPE (parmdecl) = ptr_type_node;
8428       TREE_USED (parmdecl) = 1;
8429       DECL_ARGUMENTS (fndecl) = parmdecl;
8430     }
8431
8432   pushdecl (fndecl);
8433   start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8434   do_pushlevel ();
8435
8436   interface_unknown = old_interface_unknown;
8437
8438   pop_lang_context ();
8439
8440   return current_function_decl;
8441 }
8442
8443 /* Finish the cleanup function begun by start_cleanup_fn.  */
8444
8445 static void
8446 end_cleanup_fn ()
8447 {
8448   do_poplevel ();
8449
8450   expand_body (finish_function (0));
8451
8452   pop_from_top_level ();
8453 }
8454
8455 /* Generate code to handle the destruction of DECL, an object with
8456    static storage duration.  */
8457
8458 void
8459 register_dtor_fn (decl)
8460      tree decl;
8461 {
8462   tree cleanup;
8463   tree compound_stmt;
8464   tree args;
8465   tree fcall;
8466
8467   int saved_flag_access_control;
8468
8469   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8470     return;
8471
8472   /* Call build_cleanup before we enter the anonymous function so that
8473      any access checks will be done relative to the current scope,
8474      rather than the scope of the anonymous function.  */
8475   build_cleanup (decl);
8476
8477   /* Now start the function.  */
8478   cleanup = start_cleanup_fn ();
8479
8480   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
8481      to the original function, rather than the anonymous one.  That
8482      will make the back-end think that nested functions are in use,
8483      which causes confusion.  */
8484   saved_flag_access_control = flag_access_control;
8485   flag_access_control = 0;
8486   fcall = build_cleanup (decl);
8487   flag_access_control = saved_flag_access_control;
8488
8489   /* Create the body of the anonymous function.  */
8490   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8491   finish_expr_stmt (fcall);
8492   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8493   end_cleanup_fn ();
8494
8495   /* Call atexit with the cleanup function.  */
8496   mark_addressable (cleanup);
8497   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8498   if (flag_use_cxa_atexit)
8499     {
8500       args = tree_cons (NULL_TREE, get_dso_handle_node (), NULL_TREE);
8501       args = tree_cons (NULL_TREE, null_pointer_node, args);
8502       args = tree_cons (NULL_TREE, cleanup, args);
8503     }
8504   else
8505     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8506   finish_expr_stmt (build_function_call (get_atexit_node (), args));
8507 }
8508
8509 void
8510 expand_static_init (decl, init)
8511      tree decl;
8512      tree init;
8513 {
8514   tree oldstatic = value_member (decl, static_aggregates);
8515
8516   if (oldstatic)
8517     {
8518       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8519         cp_error ("multiple initializations given for `%D'", decl);
8520     }
8521   else if (! toplevel_bindings_p ())
8522     {
8523       /* Emit code to perform this initialization but once.  */
8524       tree if_stmt;
8525       tree then_clause;
8526       tree assignment;
8527       tree guard;
8528       tree guard_init;
8529
8530       /* Emit code to perform this initialization but once.  This code
8531          looks like:
8532
8533            static int guard = 0;
8534            if (!guard) {
8535              // Do initialization.
8536              guard = 1;
8537              // Register variable for destruction at end of program.
8538            }
8539
8540          Note that the `temp' variable is only set to 1 *after* the
8541          initialization is complete.  This ensures that an exception,
8542          thrown during the construction, will cause the variable to
8543          reinitialized when we pass through this code again, as per:
8544
8545            [stmt.dcl]
8546
8547            If the initialization exits by throwing an exception, the
8548            initialization is not complete, so it will be tried again
8549            the next time control enters the declaration.
8550
8551          In theory, this process should be thread-safe, too; multiple
8552          threads should not be able to initialize the variable more
8553          than once.  We don't yet attempt to ensure thread-safety.  */
8554
8555       /* Create the guard variable.  */
8556       guard = get_guard (decl);
8557
8558       /* Begin the conditional initialization.  */
8559       if_stmt = begin_if_stmt ();
8560       finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
8561       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8562
8563       /* Do the initialization itself.  */
8564       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8565           || (init && TREE_CODE (init) == TREE_LIST))
8566         assignment = build_aggr_init (decl, init, 0);
8567       else if (init)
8568         /* The initialization we're doing here is just a bitwise
8569            copy.  */
8570         assignment = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
8571       else
8572         assignment = NULL_TREE;
8573
8574       /* Once the assignment is complete, set TEMP to 1.  Since the
8575          construction of the static object is complete at this point,
8576          we want to make sure TEMP is set to 1 even if a temporary
8577          constructed during the initialization throws an exception
8578          when it is destroyed.  So, we combine the initialization and
8579          the assignment to TEMP into a single expression, ensuring
8580          that when we call finish_expr_stmt the cleanups will not be
8581          run until after TEMP is set to 1.  */
8582       guard_init = set_guard (guard);
8583       if (assignment)
8584         {
8585           assignment = tree_cons (NULL_TREE, assignment,
8586                                   build_tree_list (NULL_TREE,
8587                                                    guard_init));
8588           assignment = build_compound_expr (assignment);
8589         }
8590       else
8591         assignment = guard_init;
8592       finish_expr_stmt (assignment);
8593
8594       /* Use atexit to register a function for destroying this static
8595          variable.  */
8596       register_dtor_fn (decl);
8597
8598       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8599       finish_then_clause (if_stmt);
8600       finish_if_stmt ();
8601     }
8602   else
8603     static_aggregates = tree_cons (init, decl, static_aggregates);
8604 }
8605
8606 /* Finish the declaration of a catch-parameter.  */
8607
8608 tree
8609 start_handler_parms (declspecs, declarator)
8610      tree declspecs;
8611      tree declarator;
8612 {
8613   tree decl;
8614   if (declspecs)
8615     {
8616       decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8617                              1, NULL_TREE);
8618       if (decl == NULL_TREE)
8619         error ("invalid catch parameter");
8620     }
8621   else
8622     decl = NULL_TREE;
8623
8624   return decl;
8625 }
8626
8627 \f
8628 /* Make TYPE a complete type based on INITIAL_VALUE.
8629    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8630    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
8631
8632 int
8633 complete_array_type (type, initial_value, do_default)
8634      tree type, initial_value;
8635      int do_default;
8636 {
8637   register tree maxindex = NULL_TREE;
8638   int value = 0;
8639
8640   if (initial_value)
8641     {
8642       /* Note MAXINDEX  is really the maximum index,
8643          one less than the size.  */
8644       if (TREE_CODE (initial_value) == STRING_CST)
8645         {
8646           int eltsize
8647             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8648           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8649                                    / eltsize) - 1, 0);
8650         }
8651       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8652         {
8653           tree elts = CONSTRUCTOR_ELTS (initial_value);
8654
8655           maxindex = ssize_int (-1);
8656           for (; elts; elts = TREE_CHAIN (elts))
8657             {
8658               if (TREE_PURPOSE (elts))
8659                 maxindex = TREE_PURPOSE (elts);
8660               else
8661                 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
8662             }
8663           maxindex = copy_node (maxindex);
8664         }
8665       else
8666         {
8667           /* Make an error message unless that happened already.  */
8668           if (initial_value != error_mark_node)
8669             value = 1;
8670           else
8671             initial_value = NULL_TREE;
8672
8673           /* Prevent further error messages.  */
8674           maxindex = build_int_2 (0, 0);
8675         }
8676     }
8677
8678   if (!maxindex)
8679     {
8680       if (do_default)
8681         maxindex = build_int_2 (0, 0);
8682       value = 2;
8683     }
8684
8685   if (maxindex)
8686     {
8687       tree itype;
8688       tree domain;
8689
8690       domain = build_index_type (maxindex);
8691       TYPE_DOMAIN (type) = domain;
8692
8693       if (! TREE_TYPE (maxindex))
8694         TREE_TYPE (maxindex) = domain;
8695       if (initial_value)
8696         itype = TREE_TYPE (initial_value);
8697       else
8698         itype = NULL;
8699       if (itype && !TYPE_DOMAIN (itype))
8700         TYPE_DOMAIN (itype) = domain;
8701       /* The type of the main variant should never be used for arrays
8702          of different sizes.  It should only ever be completed with the
8703          size of the array.  */
8704       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8705         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8706     }
8707
8708   /* Lay out the type now that we can get the real answer.  */
8709
8710   layout_type (type);
8711
8712   return value;
8713 }
8714 \f
8715 /* Return zero if something is declared to be a member of type
8716    CTYPE when in the context of CUR_TYPE.  STRING is the error
8717    message to print in that case.  Otherwise, quietly return 1.  */
8718
8719 static int
8720 member_function_or_else (ctype, cur_type, flags)
8721      tree ctype, cur_type;
8722      enum overload_flags flags;
8723 {
8724   if (ctype && ctype != cur_type)
8725     {
8726       if (flags == DTOR_FLAG)
8727         error ("destructor for alien class `%s' cannot be a member",
8728                TYPE_NAME_STRING (ctype));
8729       else
8730         error ("constructor for alien class `%s' cannot be a member",
8731                TYPE_NAME_STRING (ctype));
8732       return 0;
8733     }
8734   return 1;
8735 }
8736 \f
8737 /* Subroutine of `grokdeclarator'.  */
8738
8739 /* Generate errors possibly applicable for a given set of specifiers.
8740    This is for ARM $7.1.2.  */
8741
8742 static void
8743 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8744      tree object;
8745      const char *type;
8746      int virtualp, quals, friendp, raises, inlinep;
8747 {
8748   if (virtualp)
8749     cp_error ("`%D' declared as a `virtual' %s", object, type);
8750   if (inlinep)
8751     cp_error ("`%D' declared as an `inline' %s", object, type);
8752   if (quals)
8753     cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8754               object, type);
8755   if (friendp)
8756     cp_error_at ("`%D' declared as a friend", object);
8757   if (raises)
8758     cp_error_at ("`%D' declared with an exception specification", object);
8759 }
8760
8761 /* CTYPE is class type, or null if non-class.
8762    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8763    or METHOD_TYPE.
8764    DECLARATOR is the function's name.
8765    VIRTUALP is truthvalue of whether the function is virtual or not.
8766    FLAGS are to be passed through to `grokclassfn'.
8767    QUALS are qualifiers indicating whether the function is `const'
8768    or `volatile'.
8769    RAISES is a list of exceptions that this function can raise.
8770    CHECK is 1 if we must find this method in CTYPE, 0 if we should
8771    not look, and -1 if we should not call `grokclassfn' at all.
8772
8773    Returns `NULL_TREE' if something goes wrong, after issuing
8774    applicable error messages.  */
8775
8776 static tree
8777 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8778             raises, check, friendp, publicp, inlinep, funcdef_flag,
8779             template_count, in_namespace)
8780      tree ctype, type;
8781      tree declarator;
8782      tree orig_declarator;
8783      int virtualp;
8784      enum overload_flags flags;
8785      tree quals, raises;
8786      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8787      tree in_namespace;
8788 {
8789   tree cname, decl;
8790   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8791   int has_default_arg = 0;
8792   tree t;
8793
8794   if (ctype)
8795     cname = TREE_CODE (TYPE_NAME (ctype)) == TYPE_DECL
8796       ? TYPE_IDENTIFIER (ctype) : TYPE_NAME (ctype);
8797   else
8798     cname = NULL_TREE;
8799
8800   if (raises)
8801     {
8802       type = build_exception_variant (type, raises);
8803     }
8804
8805   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8806   /* Propagate volatile out from type to decl. */
8807   if (TYPE_VOLATILE (type))
8808     TREE_THIS_VOLATILE (decl) = 1;
8809
8810   /* If this decl has namespace scope, set that up.  */
8811   if (in_namespace)
8812     set_decl_namespace (decl, in_namespace, friendp);
8813   else if (!ctype)
8814     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8815
8816   /* `main' and builtins have implicit 'C' linkage.  */
8817   if ((MAIN_NAME_P (declarator)
8818        || (IDENTIFIER_LENGTH (declarator) > 10
8819            && IDENTIFIER_POINTER (declarator)[0] == '_'
8820            && IDENTIFIER_POINTER (declarator)[1] == '_'
8821            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8822       && current_lang_name == lang_name_cplusplus
8823       && ctype == NULL_TREE
8824       /* NULL_TREE means global namespace.  */
8825       && DECL_CONTEXT (decl) == NULL_TREE)
8826     DECL_LANGUAGE (decl) = lang_c;
8827
8828   /* Should probably propagate const out from type to decl I bet (mrs).  */
8829   if (staticp)
8830     {
8831       DECL_STATIC_FUNCTION_P (decl) = 1;
8832       DECL_CONTEXT (decl) = ctype;
8833     }
8834
8835   if (ctype)
8836     DECL_CONTEXT (decl) = ctype;
8837
8838   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8839     {
8840       if (processing_template_decl)
8841         error ("cannot declare `::main' to be a template");
8842       if (inlinep)
8843         error ("cannot declare `::main' to be inline");
8844       else if (! publicp)
8845         error ("cannot declare `::main' to be static");
8846       inlinep = 0;
8847       publicp = 1;
8848     }
8849
8850   /* Members of anonymous types and local classes have no linkage; make
8851      them internal.  */
8852   if (ctype && (ANON_AGGRNAME_P (TYPE_IDENTIFIER (ctype))
8853                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
8854     publicp = 0;
8855
8856   if (publicp)
8857     {
8858       /* [basic.link]: A name with no linkage (notably, the name of a class
8859          or enumeration declared in a local scope) shall not be used to
8860          declare an entity with linkage.
8861
8862          Only check this for public decls for now.  */
8863       t = no_linkage_check (TREE_TYPE (decl));
8864       if (t)
8865         {
8866           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8867             {
8868               if (DECL_EXTERN_C_P (decl))
8869                 /* Allow this; it's pretty common in C.  */;
8870               else
8871                 cp_pedwarn ("non-local function `%#D' uses anonymous type",
8872                             decl);
8873             }
8874           else
8875             cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8876                         decl, t);
8877         }
8878     }
8879
8880   TREE_PUBLIC (decl) = publicp;
8881   if (! publicp)
8882     {
8883       DECL_INTERFACE_KNOWN (decl) = 1;
8884       DECL_NOT_REALLY_EXTERN (decl) = 1;
8885     }
8886
8887   if (inlinep)
8888     DECL_THIS_INLINE (decl) = DECL_INLINE (decl) = 1;
8889
8890   DECL_EXTERNAL (decl) = 1;
8891   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
8892     {
8893       cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8894                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
8895       quals = NULL_TREE;
8896     }
8897
8898   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
8899     grok_op_properties (decl, virtualp, check < 0);
8900
8901   if (ctype && decl_function_context (decl))
8902     DECL_NO_STATIC_CHAIN (decl) = 1;
8903
8904   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
8905     if (TREE_PURPOSE (t)
8906         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
8907       {
8908         has_default_arg = 1;
8909         break;
8910       }
8911
8912   if (friendp
8913       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
8914     {
8915       if (funcdef_flag)
8916         cp_error
8917           ("defining explicit specialization `%D' in friend declaration",
8918            orig_declarator);
8919       else
8920         {
8921           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8922             {
8923               /* Something like `template <class T> friend void f<T>()'.  */
8924               cp_error ("invalid use of template-id `%D' in declaration of primary template",
8925                         orig_declarator);
8926               return NULL_TREE;
8927             }
8928
8929
8930           /* A friend declaration of the form friend void f<>().  Record
8931              the information in the TEMPLATE_ID_EXPR.  */
8932           SET_DECL_IMPLICIT_INSTANTIATION (decl);
8933           DECL_TEMPLATE_INFO (decl)
8934             = tree_cons (TREE_OPERAND (orig_declarator, 0),
8935                          TREE_OPERAND (orig_declarator, 1),
8936                          NULL_TREE);
8937
8938           if (has_default_arg)
8939             {
8940               cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8941                         decl);
8942               return NULL_TREE;
8943             }
8944
8945           if (inlinep)
8946             {
8947               cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
8948                         decl);
8949               return NULL_TREE;
8950             }
8951         }
8952     }
8953
8954   if (has_default_arg)
8955     add_defarg_fn (decl);
8956
8957   /* Plain overloading: will not be grok'd by grokclassfn.  */
8958   if (! ctype && ! processing_template_decl
8959       && !DECL_EXTERN_C_P (decl)
8960       && (! DECL_USE_TEMPLATE (decl) || name_mangling_version < 1))
8961     set_mangled_name_for_decl (decl);
8962
8963   if (funcdef_flag)
8964     /* Make the init_value nonzero so pushdecl knows this is not
8965        tentative.  error_mark_node is replaced later with the BLOCK.  */
8966     DECL_INITIAL (decl) = error_mark_node;
8967
8968   if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
8969     TREE_NOTHROW (decl) = 1;
8970
8971   /* Caller will do the rest of this.  */
8972   if (check < 0)
8973     return decl;
8974
8975   if (flags == NO_SPECIAL && ctype && constructor_name (cname) == declarator)
8976     DECL_CONSTRUCTOR_P (decl) = 1;
8977
8978   /* Function gets the ugly name, field gets the nice one.  This call
8979      may change the type of the function (because of default
8980      parameters)!  */
8981   if (ctype != NULL_TREE)
8982     grokclassfn (ctype, decl, flags, quals);
8983
8984   decl = check_explicit_specialization (orig_declarator, decl,
8985                                         template_count,
8986                                         2 * (funcdef_flag != 0) +
8987                                         4 * (friendp != 0));
8988   if (decl == error_mark_node)
8989     return NULL_TREE;
8990
8991   if (ctype != NULL_TREE
8992       && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
8993       && check)
8994     {
8995       tree old_decl;
8996
8997       old_decl = check_classfn (ctype, decl);
8998
8999       if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
9000         /* Because grokfndecl is always supposed to return a
9001            FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
9002            here.  We depend on our callers to figure out that its
9003            really a template that's being returned.  */
9004         old_decl = DECL_TEMPLATE_RESULT (old_decl);
9005
9006       if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
9007           && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
9008         {
9009           /* Remove the `this' parm added by grokclassfn.
9010              XXX Isn't this done in start_function, too?  */
9011           revert_static_member_fn (decl);
9012           last_function_parms = TREE_CHAIN (last_function_parms);
9013         }
9014       if (old_decl && DECL_ARTIFICIAL (old_decl))
9015         cp_error ("definition of implicitly-declared `%D'", old_decl);
9016
9017       if (old_decl)
9018         {
9019           /* Since we've smashed OLD_DECL to its
9020              DECL_TEMPLATE_RESULT, we must do the same to DECL.  */
9021           if (TREE_CODE (decl) == TEMPLATE_DECL)
9022             decl = DECL_TEMPLATE_RESULT (decl);
9023
9024           /* Attempt to merge the declarations.  This can fail, in
9025              the case of some illegal specialization declarations.  */
9026           if (!duplicate_decls (decl, old_decl))
9027             cp_error ("no `%#D' member function declared in class `%T'",
9028                       decl, ctype);
9029           return old_decl;
9030         }
9031     }
9032
9033   if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
9034     return NULL_TREE;
9035
9036   if (ctype == NULL_TREE || check)
9037     return decl;
9038
9039   if (virtualp)
9040     {
9041       DECL_VIRTUAL_P (decl) = 1;
9042       if (DECL_VINDEX (decl) == NULL_TREE)
9043         DECL_VINDEX (decl) = error_mark_node;
9044       IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
9045     }
9046
9047   return decl;
9048 }
9049
9050 static tree
9051 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
9052      tree type;
9053      tree declarator;
9054      RID_BIT_TYPE *specbits_in;
9055      int initialized;
9056      int constp;
9057      tree in_namespace;
9058 {
9059   tree decl;
9060   RID_BIT_TYPE specbits;
9061
9062   specbits = *specbits_in;
9063
9064   if (TREE_CODE (type) == OFFSET_TYPE)
9065     {
9066       /* If you declare a static member so that it
9067          can be initialized, the code will reach here.  */
9068       tree basetype = TYPE_OFFSET_BASETYPE (type);
9069       type = TREE_TYPE (type);
9070       decl = build_lang_decl (VAR_DECL, declarator, type);
9071       DECL_CONTEXT (decl) = basetype;
9072       /* DECL_ASSEMBLER_NAME is needed only for full-instantiated
9073          templates.  */
9074       if (!uses_template_parms (decl))
9075         {
9076           if (flag_new_abi)
9077             DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
9078           else
9079             DECL_ASSEMBLER_NAME (decl) = build_static_name (basetype,
9080                                                             declarator);
9081         }
9082     }
9083   else
9084     {
9085       tree context;
9086
9087       if (in_namespace)
9088         context = in_namespace;
9089       else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
9090         context = current_namespace;
9091       else
9092         context = NULL_TREE;
9093
9094       if (processing_template_decl && context)
9095         /* For global variables, declared in a template, we need the
9096            full lang_decl.  */
9097         decl = build_lang_decl (VAR_DECL, declarator, type);
9098       else
9099         decl = build_decl (VAR_DECL, declarator, type);
9100
9101       if (context)
9102         set_decl_namespace (decl, context, 0);
9103
9104       context = DECL_CONTEXT (decl);
9105       if (declarator && context && current_lang_name != lang_name_c)
9106         {
9107           if (flag_new_abi)
9108             DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
9109           else
9110             DECL_ASSEMBLER_NAME (decl)
9111               = build_static_name (context, declarator);
9112         }
9113     }
9114
9115   if (in_namespace)
9116     set_decl_namespace (decl, in_namespace, 0);
9117
9118   if (RIDBIT_SETP (RID_EXTERN, specbits))
9119     {
9120       DECL_THIS_EXTERN (decl) = 1;
9121       DECL_EXTERNAL (decl) = !initialized;
9122     }
9123
9124   /* In class context, static means one per class,
9125      public access, and static storage.  */
9126   if (DECL_CLASS_SCOPE_P (decl))
9127     {
9128       TREE_PUBLIC (decl) = 1;
9129       TREE_STATIC (decl) = 1;
9130       DECL_EXTERNAL (decl) = 0;
9131     }
9132   /* At top level, either `static' or no s.c. makes a definition
9133      (perhaps tentative), and absence of `static' makes it public.  */
9134   else if (toplevel_bindings_p ())
9135     {
9136       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
9137                             && (DECL_THIS_EXTERN (decl) || ! constp));
9138       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
9139     }
9140   /* Not at top level, only `static' makes a static definition.  */
9141   else
9142     {
9143       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
9144       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
9145     }
9146
9147   if (TREE_PUBLIC (decl))
9148     {
9149       /* [basic.link]: A name with no linkage (notably, the name of a class
9150          or enumeration declared in a local scope) shall not be used to
9151          declare an entity with linkage.
9152
9153          Only check this for public decls for now.  */
9154       tree t = no_linkage_check (TREE_TYPE (decl));
9155       if (t)
9156         {
9157           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
9158             /* Ignore for now; `enum { foo } e' is pretty common.  */;
9159           else
9160             cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
9161                         decl, t);
9162         }
9163     }
9164
9165   return decl;
9166 }
9167
9168 /* Create and return a canonical pointer to member function type, for
9169    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
9170
9171 tree
9172 build_ptrmemfunc_type (type)
9173      tree type;
9174 {
9175   tree fields[4];
9176   tree t;
9177   tree u;
9178   tree unqualified_variant = NULL_TREE;
9179
9180   /* If a canonical type already exists for this type, use it.  We use
9181      this method instead of type_hash_canon, because it only does a
9182      simple equality check on the list of field members.  */
9183
9184   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
9185     return t;
9186
9187   /* Make sure that we always have the unqualified pointer-to-member
9188      type first.  */
9189   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9190     unqualified_variant
9191       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
9192
9193   t = make_aggr_type (RECORD_TYPE);
9194   /* Let the front-end know this is a pointer to member function...  */
9195   TYPE_PTRMEMFUNC_FLAG (t) = 1;
9196   /* ... and not really an aggregate.  */
9197   SET_IS_AGGR_TYPE (t, 0);
9198
9199   if (!flag_new_abi)
9200     {
9201       u = make_aggr_type (UNION_TYPE);
9202       SET_IS_AGGR_TYPE (u, 0);
9203       fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9204       fields[1] = build_decl (FIELD_DECL, delta2_identifier,
9205                               delta_type_node);
9206       finish_builtin_type (u, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9207       TYPE_NAME (u) = NULL_TREE;
9208
9209       fields[0] = build_decl (FIELD_DECL, delta_identifier,
9210                               delta_type_node);
9211       fields[1] = build_decl (FIELD_DECL, index_identifier,
9212                               delta_type_node);
9213       fields[2] = build_decl (FIELD_DECL, pfn_or_delta2_identifier, u);
9214       finish_builtin_type (t, "__ptrmemfunc_type", fields, 2, ptr_type_node);
9215     }
9216   else
9217     {
9218       fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9219       fields[1] = build_decl (FIELD_DECL, delta_identifier,
9220                               delta_type_node);
9221       finish_builtin_type (t, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9222     }
9223
9224   /* Zap out the name so that the back-end will give us the debugging
9225      information for this anonymous RECORD_TYPE.  */
9226   TYPE_NAME (t) = NULL_TREE;
9227
9228   /* If this is not the unqualified form of this pointer-to-member
9229      type, set the TYPE_MAIN_VARIANT for this type to be the
9230      unqualified type.  Since they are actually RECORD_TYPEs that are
9231      not variants of each other, we must do this manually.  */
9232   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9233     {
9234       t = build_qualified_type (t, CP_TYPE_QUALS (type));
9235       TYPE_MAIN_VARIANT (t) = unqualified_variant;
9236       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
9237       TYPE_NEXT_VARIANT (unqualified_variant) = t;
9238     }
9239
9240   /* Cache this pointer-to-member type so that we can find it again
9241      later.  */
9242   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
9243
9244   /* Seems to be wanted.  */
9245   CLASSTYPE_GOT_SEMICOLON (t) = 1;
9246
9247   return t;
9248 }
9249
9250 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9251    Check to see that the definition is valid.  Issue appropriate error
9252    messages.  Return 1 if the definition is particularly bad, or 0
9253    otherwise.  */
9254
9255 int
9256 check_static_variable_definition (decl, type)
9257      tree decl;
9258      tree type;
9259 {
9260   /* Motion 10 at San Diego: If a static const integral data member is
9261      initialized with an integral constant expression, the initializer
9262      may appear either in the declaration (within the class), or in
9263      the definition, but not both.  If it appears in the class, the
9264      member is a member constant.  The file-scope definition is always
9265      required.  */
9266   if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
9267     {
9268       cp_error ("invalid in-class initialization of static data member of non-integral type `%T'",
9269                 type);
9270       /* If we just return the declaration, crashes will sometimes
9271          occur.  We therefore return void_type_node, as if this was a
9272          friend declaration, to cause callers to completely ignore
9273          this declaration.  */
9274       return 1;
9275     }
9276   else if (!CP_TYPE_CONST_P (type))
9277     cp_error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9278               decl);
9279   else if (pedantic && !INTEGRAL_TYPE_P (type))
9280     cp_pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
9281
9282   return 0;
9283 }
9284
9285 /* Given the SIZE (i.e., number of elements) in an array, compute an
9286    appropriate index type for the array.  If non-NULL, NAME is the
9287    name of the thing being declared.  */
9288
9289 tree
9290 compute_array_index_type (name, size)
9291      tree name;
9292      tree size;
9293 {
9294   tree itype;
9295
9296   /* The size might be the result of a cast. */
9297   STRIP_TYPE_NOPS (size);
9298
9299   /* It might be a const variable or enumeration constant.  */
9300   size = decl_constant_value (size);
9301
9302   /* If this involves a template parameter, it will be a constant at
9303      instantiation time, but we don't know what the value is yet.
9304      Even if no template parameters are involved, we may an expression
9305      that is not a constant; we don't even simplify `1 + 2' when
9306      processing a template.  */
9307   if (processing_template_decl)
9308     {
9309       /* Resolve a qualified reference to an enumerator or static
9310          const data member of ours.  */
9311       if (TREE_CODE (size) == SCOPE_REF
9312           && TREE_OPERAND (size, 0) == current_class_type)
9313         {
9314           tree t = lookup_field (current_class_type,
9315                                  TREE_OPERAND (size, 1), 0, 0);
9316           if (t)
9317             size = t;
9318         }
9319
9320       return build_index_type (build_min (MINUS_EXPR, sizetype,
9321                                           size, integer_one_node));
9322     }
9323
9324   /* The array bound must be an integer type.  */
9325   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9326       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
9327       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
9328     {
9329       if (name)
9330         cp_error ("size of array `%D' has non-integer type", name);
9331       else
9332         cp_error ("size of array has non-integer type");
9333       size = integer_one_node;
9334     }
9335
9336   /* Normally, the array-bound will be a constant.  */
9337   if (TREE_CONSTANT (size))
9338     {
9339       /* Check to see if the array bound overflowed.  Make that an
9340          error, no matter how generous we're being.  */
9341       int old_flag_pedantic_errors = flag_pedantic_errors;
9342       int old_pedantic = pedantic;
9343       pedantic = flag_pedantic_errors = 1;
9344       constant_expression_warning (size);
9345       pedantic = old_pedantic;
9346       flag_pedantic_errors = old_flag_pedantic_errors;
9347
9348       /* An array must have a positive number of elements.  */
9349       if (INT_CST_LT (size, integer_zero_node))
9350         {
9351           if (name)
9352             cp_error ("size of array `%D' is negative", name);
9353           else
9354             cp_error ("size of array is negative");
9355           size = integer_one_node;
9356         }
9357       /* Except that an extension we allow zero-sized arrays.  We
9358          always allow them in system headers because glibc uses
9359          them.  */
9360       else if (integer_zerop (size) && pedantic && !in_system_header)
9361         {
9362           if (name)
9363             cp_pedwarn ("ISO C++ forbids zero-size array `%D'", name);
9364           else
9365             cp_pedwarn ("ISO C++ forbids zero-size array");
9366         }
9367     }
9368
9369   /* Compute the index of the largest element in the array.  It is
9370      one less than the number of elements in the array.  */
9371   itype
9372     = fold (cp_build_binary_op (MINUS_EXPR,
9373                                 cp_convert (ssizetype, size),
9374                                 cp_convert (ssizetype,
9375                                             integer_one_node)));
9376
9377   /* Check for variable-sized arrays.  We allow such things as an
9378      extension, even though they are not allowed in ANSI/ISO C++.  */
9379   if (!TREE_CONSTANT (itype))
9380     {
9381       if (pedantic)
9382         {
9383           if (name)
9384             cp_pedwarn ("ISO C++ forbids variable-size array `%D'",
9385                         name);
9386           else
9387             cp_pedwarn ("ISO C++ forbids variable-size array");
9388         }
9389
9390       /* Create a variable-sized array index type.  */
9391       itype = variable_size (itype);
9392     }
9393   /* Make sure that there was no overflow when creating to a signed
9394      index type.  (For example, on a 32-bit machine, an array with
9395      size 2^32 - 1 is too big.)  */
9396   else if (TREE_OVERFLOW (itype))
9397     {
9398       error ("overflow in array dimension");
9399       TREE_OVERFLOW (itype) = 0;
9400     }
9401
9402   /* Create and return the appropriate index type.  */
9403   return build_index_type (itype);
9404 }
9405
9406 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9407    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
9408    with this type.  */
9409
9410 static tree
9411 create_array_type_for_decl (name, type, size)
9412      tree name;
9413      tree type;
9414      tree size;
9415 {
9416   tree itype = NULL_TREE;
9417   const char* error_msg;
9418
9419   /* If things have already gone awry, bail now.  */
9420   if (type == error_mark_node || size == error_mark_node)
9421     return error_mark_node;
9422
9423   /* Assume that everything will go OK.  */
9424   error_msg = NULL;
9425
9426   /* There are some types which cannot be array elements.  */
9427   switch (TREE_CODE (type))
9428     {
9429     case VOID_TYPE:
9430       error_msg = "array of void";
9431       break;
9432
9433     case FUNCTION_TYPE:
9434       error_msg = "array of functions";
9435       break;
9436
9437     case REFERENCE_TYPE:
9438       error_msg = "array of references";
9439       break;
9440
9441     case OFFSET_TYPE:
9442       error_msg = "array of data members";
9443       break;
9444
9445     case METHOD_TYPE:
9446       error_msg = "array of function members";
9447       break;
9448
9449     default:
9450       break;
9451     }
9452
9453   /* If something went wrong, issue an error-message and return.  */
9454   if (error_msg)
9455     {
9456       if (name)
9457         cp_error ("declaration of `%D' as %s", name, error_msg);
9458       else
9459         cp_error ("creating %s", error_msg);
9460
9461       return error_mark_node;
9462     }
9463
9464   /* [dcl.array]
9465
9466      The constant expressions that specify the bounds of the arrays
9467      can be omitted only for the first member of the sequence.  */
9468   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9469     {
9470       cp_error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9471                 name);
9472
9473       return error_mark_node;
9474     }
9475
9476   /* Figure out the index type for the array.  */
9477   if (size)
9478     itype = compute_array_index_type (name, size);
9479
9480   return build_cplus_array_type (type, itype);
9481 }
9482
9483 /* Check that it's OK to declare a function with the indicated TYPE.
9484    SFK indicates the kind of special function (if any) that this
9485    function is.  CTYPE is the class of which this function is a
9486    member.  OPTYPE is the type given in a conversion operator
9487    declaration.  Returns the actual return type of the function; that
9488    may be different than TYPE if an error occurs, or for certain
9489    special functions.  */
9490
9491 static tree
9492 check_special_function_return_type (sfk, type, ctype, optype)
9493      special_function_kind sfk;
9494      tree type;
9495      tree ctype;
9496      tree optype;
9497 {
9498   switch (sfk)
9499     {
9500     case sfk_constructor:
9501       if (type)
9502         cp_error ("return type specification for constructor invalid");
9503
9504       /* In the old ABI, we return `this'; in the new ABI we don't
9505          bother.  */
9506       type = flag_new_abi ? void_type_node : build_pointer_type (ctype);
9507       break;
9508
9509     case sfk_destructor:
9510       if (type)
9511         cp_error ("return type specification for destructor invalid");
9512       type = void_type_node;
9513       break;
9514
9515     case sfk_conversion:
9516       if (type && !same_type_p (type, optype))
9517         cp_error ("operator `%T' declared to return `%T'", optype, type);
9518       else if (type)
9519         cp_pedwarn ("return type specified for `operator %T'",  optype);
9520       type = optype;
9521       break;
9522
9523     default:
9524       my_friendly_abort (20000408);
9525       break;
9526     }
9527
9528   return type;
9529 }
9530
9531 /* Given declspecs and a declarator,
9532    determine the name and type of the object declared
9533    and construct a ..._DECL node for it.
9534    (In one case we can return a ..._TYPE node instead.
9535     For invalid input we sometimes return 0.)
9536
9537    DECLSPECS is a chain of tree_list nodes whose value fields
9538     are the storage classes and type specifiers.
9539
9540    DECL_CONTEXT says which syntactic context this declaration is in:
9541      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9542      FUNCDEF for a function definition.  Like NORMAL but a few different
9543       error messages in each case.  Return value may be zero meaning
9544       this definition is too screwy to try to parse.
9545      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
9546       handle member functions (which have FIELD context).
9547       Return value may be zero meaning this definition is too screwy to
9548       try to parse.
9549      PARM for a parameter declaration (either within a function prototype
9550       or before a function body).  Make a PARM_DECL, or return void_type_node.
9551      CATCHPARM for a parameter declaration before a catch clause.
9552      TYPENAME if for a typename (in a cast or sizeof).
9553       Don't make a DECL node; just return the ..._TYPE node.
9554      FIELD for a struct or union field; make a FIELD_DECL.
9555      BITFIELD for a field with specified width.
9556    INITIALIZED is 1 if the decl has an initializer.
9557
9558    ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
9559    normal attributes in TREE_PURPOSE, or NULL_TREE.
9560
9561    In the TYPENAME case, DECLARATOR is really an abstract declarator.
9562    It may also be so in the PARM case, for a prototype where the
9563    argument type is specified but not the name.
9564
9565    This function is where the complicated C meanings of `static'
9566    and `extern' are interpreted.
9567
9568    For C++, if there is any monkey business to do, the function which
9569    calls this one must do it, i.e., prepending instance variables,
9570    renaming overloaded function names, etc.
9571
9572    Note that for this C++, it is an error to define a method within a class
9573    which does not belong to that class.
9574
9575    Except in the case where SCOPE_REFs are implicitly known (such as
9576    methods within a class being redundantly qualified),
9577    declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9578    (class_name::decl_name).  The caller must also deal with this.
9579
9580    If a constructor or destructor is seen, and the context is FIELD,
9581    then the type gains the attribute TREE_HAS_x.  If such a declaration
9582    is erroneous, NULL_TREE is returned.
9583
9584    QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
9585    function, these are the qualifiers to give to the `this' pointer. We
9586    apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9587
9588    May return void_type_node if the declarator turned out to be a friend.
9589    See grokfield for details.  */
9590
9591 tree
9592 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9593      tree declspecs;
9594      tree declarator;
9595      enum decl_context decl_context;
9596      int initialized;
9597      tree attrlist;
9598 {
9599   RID_BIT_TYPE specbits;
9600   int nclasses = 0;
9601   tree spec;
9602   tree type = NULL_TREE;
9603   int longlong = 0;
9604   int constp;
9605   int restrictp;
9606   int volatilep;
9607   int type_quals;
9608   int virtualp, explicitp, friendp, inlinep, staticp;
9609   int explicit_int = 0;
9610   int explicit_char = 0;
9611   int defaulted_int = 0;
9612   tree typedef_decl = NULL_TREE;
9613   const char *name;
9614   tree typedef_type = NULL_TREE;
9615   int funcdef_flag = 0;
9616   enum tree_code innermost_code = ERROR_MARK;
9617   int bitfield = 0;
9618 #if 0
9619   /* See the code below that used this.  */
9620   tree decl_machine_attr = NULL_TREE;
9621 #endif
9622   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9623      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9624   tree init = NULL_TREE;
9625
9626   /* Keep track of what sort of function is being processed
9627      so that we can warn about default return values, or explicit
9628      return values which do not match prescribed defaults.  */
9629   special_function_kind sfk = sfk_none;
9630
9631   tree dname = NULL_TREE;
9632   tree ctype = current_class_type;
9633   tree ctor_return_type = NULL_TREE;
9634   enum overload_flags flags = NO_SPECIAL;
9635   tree quals = NULL_TREE;
9636   tree raises = NULL_TREE;
9637   int template_count = 0;
9638   tree in_namespace = NULL_TREE;
9639   tree inner_attrs;
9640   int ignore_attrs;
9641
9642   RIDBIT_RESET_ALL (specbits);
9643   if (decl_context == FUNCDEF)
9644     funcdef_flag = 1, decl_context = NORMAL;
9645   else if (decl_context == MEMFUNCDEF)
9646     funcdef_flag = -1, decl_context = FIELD;
9647   else if (decl_context == BITFIELD)
9648     bitfield = 1, decl_context = FIELD;
9649
9650   /* Look inside a declarator for the name being declared
9651      and get it as a string, for an error message.  */
9652   {
9653     tree *next = &declarator;
9654     register tree decl;
9655     name = NULL;
9656
9657     while (next && *next)
9658       {
9659         decl = *next;
9660         switch (TREE_CODE (decl))
9661           {
9662           case TREE_LIST:
9663             /* For attributes.  */
9664             next = &TREE_VALUE (decl);
9665             break;
9666
9667           case COND_EXPR:
9668             ctype = NULL_TREE;
9669             next = &TREE_OPERAND (decl, 0);
9670             break;
9671
9672           case BIT_NOT_EXPR:    /* For C++ destructors!  */
9673             {
9674               tree name = TREE_OPERAND (decl, 0);
9675               tree rename = NULL_TREE;
9676
9677               my_friendly_assert (flags == NO_SPECIAL, 152);
9678               flags = DTOR_FLAG;
9679               sfk = sfk_destructor;
9680               if (TREE_CODE (name) == TYPE_DECL)
9681                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9682               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9683               if (ctype == NULL_TREE)
9684                 {
9685                   if (current_class_type == NULL_TREE)
9686                     {
9687                       error ("destructors must be member functions");
9688                       flags = NO_SPECIAL;
9689                     }
9690                   else
9691                     {
9692                       tree t = constructor_name (current_class_name);
9693                       if (t != name)
9694                         rename = t;
9695                     }
9696                 }
9697               else
9698                 {
9699                   tree t = constructor_name (ctype);
9700                   if (t != name)
9701                     rename = t;
9702                 }
9703
9704               if (rename)
9705                 {
9706                   cp_error ("destructor `%T' must match class name `%T'",
9707                             name, rename);
9708                   TREE_OPERAND (decl, 0) = rename;
9709                 }
9710               next = &name;
9711             }
9712             break;
9713
9714           case ADDR_EXPR:       /* C++ reference declaration */
9715             /* Fall through. */
9716           case ARRAY_REF:
9717           case INDIRECT_REF:
9718             ctype = NULL_TREE;
9719             innermost_code = TREE_CODE (decl);
9720             next = &TREE_OPERAND (decl, 0);
9721             break;
9722
9723           case CALL_EXPR:
9724             if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
9725               {
9726                 /* This is actually a variable declaration using
9727                    constructor syntax.  We need to call start_decl and
9728                    cp_finish_decl so we can get the variable
9729                    initialized...  */
9730
9731                 tree attributes, prefix_attributes;
9732
9733                 *next = TREE_OPERAND (decl, 0);
9734                 init = CALL_DECLARATOR_PARMS (decl);
9735
9736                 if (attrlist)
9737                   {
9738                     attributes = TREE_PURPOSE (attrlist);
9739                     prefix_attributes = TREE_VALUE (attrlist);
9740                   }
9741                 else
9742                   {
9743                     attributes = NULL_TREE;
9744                     prefix_attributes = NULL_TREE;
9745                   }
9746
9747                 decl = start_decl (declarator, declspecs, 1,
9748                                    attributes, prefix_attributes);
9749                 decl_type_access_control (decl);
9750                 if (decl)
9751                   {
9752                     /* Look for __unused__ attribute */
9753                     if (TREE_USED (TREE_TYPE (decl)))
9754                       TREE_USED (decl) = 1;
9755                     finish_decl (decl, init, NULL_TREE);
9756                   }
9757                 else
9758                   cp_error ("invalid declarator");
9759                 return 0;
9760               }
9761             innermost_code = TREE_CODE (decl);
9762             if (decl_context == FIELD && ctype == NULL_TREE)
9763               ctype = current_class_type;
9764             if (ctype
9765                 && TREE_OPERAND (decl, 0)
9766                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9767                     && ((DECL_NAME (TREE_OPERAND (decl, 0))
9768                          == constructor_name_full (ctype))
9769                         || (DECL_NAME (TREE_OPERAND (decl, 0))
9770                             == constructor_name (ctype)))))
9771               TREE_OPERAND (decl, 0) = constructor_name (ctype);
9772             next = &TREE_OPERAND (decl, 0);
9773             decl = *next;
9774             if (ctype != NULL_TREE
9775                 && decl != NULL_TREE && flags != DTOR_FLAG
9776                 && decl == constructor_name (ctype))
9777               {
9778                 sfk = sfk_constructor;
9779                 ctor_return_type = ctype;
9780               }
9781             ctype = NULL_TREE;
9782             break;
9783
9784           case TEMPLATE_ID_EXPR:
9785               {
9786                 tree fns = TREE_OPERAND (decl, 0);
9787
9788                 if (TREE_CODE (fns) == LOOKUP_EXPR)
9789                   fns = TREE_OPERAND (fns, 0);
9790
9791                 dname = fns;
9792                 if (TREE_CODE (dname) == COMPONENT_REF)
9793                   dname = TREE_OPERAND (dname, 1);
9794                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9795                   {
9796                     my_friendly_assert (is_overloaded_fn (dname),
9797                                         19990331);
9798                     dname = DECL_NAME (get_first_fn (dname));
9799                   }
9800               }
9801           /* Fall through. */
9802
9803           case IDENTIFIER_NODE:
9804             if (TREE_CODE (decl) == IDENTIFIER_NODE)
9805               dname = decl;
9806
9807             next = 0;
9808
9809             if (is_rid (dname))
9810               {
9811                 cp_error ("declarator-id missing; using reserved word `%D'",
9812                           dname);
9813                 name = IDENTIFIER_POINTER (dname);
9814               }
9815             else if (!IDENTIFIER_TYPENAME_P (dname))
9816               name = IDENTIFIER_POINTER (dname);
9817             else
9818               {
9819                 my_friendly_assert (flags == NO_SPECIAL, 154);
9820                 flags = TYPENAME_FLAG;
9821                 ctor_return_type = TREE_TYPE (dname);
9822                 sfk = sfk_conversion;
9823                 if (IDENTIFIER_GLOBAL_VALUE (dname)
9824                     && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (dname))
9825                         == TYPE_DECL))
9826                   name = IDENTIFIER_POINTER (dname);
9827                 else
9828                   name = "<invalid operator>";
9829               }
9830             break;
9831
9832             /* C++ extension */
9833           case SCOPE_REF:
9834             {
9835               /* Perform error checking, and decide on a ctype.  */
9836               tree cname = TREE_OPERAND (decl, 0);
9837               if (cname == NULL_TREE)
9838                 ctype = NULL_TREE;
9839               else if (TREE_CODE (cname) == NAMESPACE_DECL)
9840                 {
9841                   ctype = NULL_TREE;
9842                   in_namespace = TREE_OPERAND (decl, 0);
9843                   TREE_OPERAND (decl, 0) = NULL_TREE;
9844                 }
9845               else if (! is_aggr_type (cname, 1))
9846                 TREE_OPERAND (decl, 0) = NULL_TREE;
9847               /* Must test TREE_OPERAND (decl, 1), in case user gives
9848                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
9849               else if (TREE_OPERAND (decl, 1)
9850                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9851                 ctype = cname;
9852               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9853                        || TREE_CODE (cname) == TEMPLATE_TEMPLATE_PARM)
9854                 {
9855                   cp_error ("`%T::%D' is not a valid declarator", cname,
9856                             TREE_OPERAND (decl, 1));
9857                   cp_error ("  perhaps you want `typename %T::%D' to make it a type",
9858                             cname, TREE_OPERAND (decl, 1));
9859                   return void_type_node;
9860                 }
9861               else if (ctype == NULL_TREE)
9862                 ctype = cname;
9863               else if (TREE_COMPLEXITY (decl) == current_class_depth)
9864                 TREE_OPERAND (decl, 0) = ctype;
9865               else
9866                 {
9867                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9868                     {
9869                       cp_error ("type `%T' is not derived from type `%T'",
9870                                 cname, ctype);
9871                       TREE_OPERAND (decl, 0) = NULL_TREE;
9872                     }
9873                   else
9874                     ctype = cname;
9875                 }
9876
9877               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
9878                   && ((DECL_NAME (TREE_OPERAND (decl, 1))
9879                        == constructor_name_full (ctype))
9880                       || (DECL_NAME (TREE_OPERAND (decl, 1))
9881                           == constructor_name (ctype))))
9882                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
9883               next = &TREE_OPERAND (decl, 1);
9884               decl = *next;
9885               if (ctype)
9886                 {
9887                   if (TREE_CODE (decl) == IDENTIFIER_NODE
9888                       && constructor_name (ctype) == decl)
9889                     {
9890                       sfk = sfk_constructor;
9891                       ctor_return_type = ctype;
9892                     }
9893                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
9894                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
9895                            && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
9896                                || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
9897                     {
9898                       sfk = sfk_destructor;
9899                       ctor_return_type = ctype;
9900                       flags = DTOR_FLAG;
9901                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
9902                       next = &TREE_OPERAND (decl, 0);
9903                     }
9904                 }
9905             }
9906             break;
9907
9908           case ERROR_MARK:
9909             next = 0;
9910             break;
9911
9912           case TYPE_DECL:
9913             /* Parse error puts this typespec where
9914                a declarator should go.  */
9915             cp_error ("`%T' specified as declarator-id", DECL_NAME (decl));
9916             if (TREE_TYPE (decl) == current_class_type)
9917               cp_error ("  perhaps you want `%T' for a constructor",
9918                         current_class_name);
9919             dname = DECL_NAME (decl);
9920             name = IDENTIFIER_POINTER (dname);
9921
9922             /* Avoid giving two errors for this.  */
9923             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
9924
9925             declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
9926             *next = dname;
9927             next = 0;
9928             break;
9929
9930           default:
9931             cp_compiler_error ("`%D' as declarator", decl);
9932             return 0; /* We used to do a 155 abort here.  */
9933           }
9934       }
9935   }
9936
9937   /* A function definition's declarator must have the form of
9938      a function declarator.  */
9939
9940   if (funcdef_flag && innermost_code != CALL_EXPR)
9941     return 0;
9942
9943   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
9944       && innermost_code != CALL_EXPR
9945       && ! (ctype && declspecs == NULL_TREE))
9946     {
9947       cp_error ("declaration of `%D' as non-function", dname);
9948       return void_type_node;
9949     }
9950
9951   /* Anything declared one level down from the top level
9952      must be one of the parameters of a function
9953      (because the body is at least two levels down).  */
9954
9955   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9956      by not allowing C++ class definitions to specify their parameters
9957      with xdecls (must be spec.d in the parmlist).
9958
9959      Since we now wait to push a class scope until we are sure that
9960      we are in a legitimate method context, we must set oldcname
9961      explicitly (since current_class_name is not yet alive).
9962
9963      We also want to avoid calling this a PARM if it is in a namespace.  */
9964
9965   if (decl_context == NORMAL && !toplevel_bindings_p ())
9966     {
9967       struct binding_level *b = current_binding_level;
9968       current_binding_level = b->level_chain;
9969       if (current_binding_level != 0 && toplevel_bindings_p ())
9970         decl_context = PARM;
9971       current_binding_level = b;
9972     }
9973
9974   if (name == NULL)
9975     name = decl_context == PARM ? "parameter" : "type name";
9976
9977   /* Look through the decl specs and record which ones appear.
9978      Some typespecs are defined as built-in typenames.
9979      Others, the ones that are modifiers of other types,
9980      are represented by bits in SPECBITS: set the bits for
9981      the modifiers that appear.  Storage class keywords are also in SPECBITS.
9982
9983      If there is a typedef name or a type, store the type in TYPE.
9984      This includes builtin typedefs such as `int'.
9985
9986      Set EXPLICIT_INT if the type is `int' or `char' and did not
9987      come from a user typedef.
9988
9989      Set LONGLONG if `long' is mentioned twice.
9990
9991      For C++, constructors and destructors have their own fast treatment.  */
9992
9993   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
9994     {
9995       register int i;
9996       register tree id;
9997
9998       /* Certain parse errors slip through.  For example,
9999          `int class;' is not caught by the parser. Try
10000          weakly to recover here.  */
10001       if (TREE_CODE (spec) != TREE_LIST)
10002         return 0;
10003
10004       id = TREE_VALUE (spec);
10005
10006       if (TREE_CODE (id) == IDENTIFIER_NODE)
10007         {
10008           if (id == ridpointers[(int) RID_INT]
10009               || id == ridpointers[(int) RID_CHAR]
10010               || id == ridpointers[(int) RID_BOOL]
10011               || id == ridpointers[(int) RID_WCHAR])
10012             {
10013               if (type)
10014                 {
10015                   if (id == ridpointers[(int) RID_BOOL])
10016                     error ("`bool' is now a keyword");
10017                   else
10018                     cp_error ("extraneous `%T' ignored", id);
10019                 }
10020               else
10021                 {
10022                   if (id == ridpointers[(int) RID_INT])
10023                     explicit_int = 1;
10024                   else if (id == ridpointers[(int) RID_CHAR])
10025                     explicit_char = 1;
10026                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
10027                 }
10028               goto found;
10029             }
10030           /* C++ aggregate types.  */
10031           if (IDENTIFIER_HAS_TYPE_VALUE (id))
10032             {
10033               if (type)
10034                 cp_error ("multiple declarations `%T' and `%T'", type, id);
10035               else
10036                 type = IDENTIFIER_TYPE_VALUE (id);
10037               goto found;
10038             }
10039
10040           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
10041             {
10042               if (ridpointers[i] == id)
10043                 {
10044                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
10045                     {
10046                       if (pedantic && ! in_system_header && warn_long_long)
10047                         pedwarn ("ISO C++ does not support `long long'");
10048                       if (longlong)
10049                         error ("`long long long' is too long for GCC");
10050                       else
10051                         longlong = 1;
10052                     }
10053                   else if (RIDBIT_SETP (i, specbits))
10054                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
10055                   RIDBIT_SET (i, specbits);
10056                   goto found;
10057                 }
10058             }
10059         }
10060       /* C++ aggregate types.  */
10061       else if (TREE_CODE (id) == TYPE_DECL)
10062         {
10063           if (type)
10064             cp_error ("multiple declarations `%T' and `%T'", type,
10065                       TREE_TYPE (id));
10066           else
10067             {
10068               type = TREE_TYPE (id);
10069               TREE_VALUE (spec) = type;
10070             }
10071           goto found;
10072         }
10073       if (type)
10074         error ("two or more data types in declaration of `%s'", name);
10075       else if (TREE_CODE (id) == IDENTIFIER_NODE)
10076         {
10077           register tree t = lookup_name (id, 1);
10078           if (!t || TREE_CODE (t) != TYPE_DECL)
10079             error ("`%s' fails to be a typedef or built in type",
10080                    IDENTIFIER_POINTER (id));
10081           else
10082             {
10083               type = TREE_TYPE (t);
10084 #if 0
10085               /* See the code below that used this.  */
10086               decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
10087 #endif
10088               typedef_decl = t;
10089             }
10090         }
10091       else if (id != error_mark_node)
10092         /* Can't change CLASS nodes into RECORD nodes here!  */
10093         type = id;
10094
10095     found: ;
10096     }
10097
10098   typedef_type = type;
10099
10100   /* No type at all: default to `int', and set DEFAULTED_INT
10101      because it was not a user-defined typedef.  */
10102
10103   if (type == NULL_TREE
10104       && (RIDBIT_SETP (RID_SIGNED, specbits)
10105           || RIDBIT_SETP (RID_UNSIGNED, specbits)
10106           || RIDBIT_SETP (RID_LONG, specbits)
10107           || RIDBIT_SETP (RID_SHORT, specbits)))
10108     {
10109       /* These imply 'int'.  */
10110       type = integer_type_node;
10111       defaulted_int = 1;
10112     }
10113
10114   if (sfk != sfk_none)
10115     type = check_special_function_return_type (sfk, type,
10116                                                ctor_return_type,
10117                                                ctor_return_type);
10118   else if (type == NULL_TREE)
10119     {
10120       int is_main;
10121
10122       explicit_int = -1;
10123
10124           /* We handle `main' specially here, because 'main () { }' is so
10125              common.  With no options, it is allowed.  With -Wreturn-type,
10126              it is a warning.  It is only an error with -pedantic-errors.  */
10127       is_main = (funcdef_flag
10128                  && MAIN_NAME_P (dname)
10129                  && ctype == NULL_TREE
10130                  && in_namespace == NULL_TREE
10131                  && current_namespace == global_namespace);
10132
10133       if (in_system_header || flag_ms_extensions)
10134         /* Allow it, sigh.  */;
10135       else if (pedantic || ! is_main)
10136         cp_pedwarn ("ISO C++ forbids declaration of `%s' with no type",
10137                     name);
10138       else if (warn_return_type)
10139         cp_warning ("ISO C++ forbids declaration of `%s' with no type",
10140                     name);
10141
10142       type = integer_type_node;
10143     }
10144
10145   ctype = NULL_TREE;
10146
10147   /* Now process the modifiers that were specified
10148      and check for invalid combinations.  */
10149
10150   /* Long double is a special combination.  */
10151
10152   if (RIDBIT_SETP (RID_LONG, specbits)
10153       && TYPE_MAIN_VARIANT (type) == double_type_node)
10154     {
10155       RIDBIT_RESET (RID_LONG, specbits);
10156       type = build_qualified_type (long_double_type_node,
10157                                    CP_TYPE_QUALS (type));
10158     }
10159
10160   /* Check all other uses of type modifiers.  */
10161
10162   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10163       || RIDBIT_SETP (RID_SIGNED, specbits)
10164       || RIDBIT_SETP (RID_LONG, specbits)
10165       || RIDBIT_SETP (RID_SHORT, specbits))
10166     {
10167       int ok = 0;
10168
10169       if (TREE_CODE (type) == REAL_TYPE)
10170         error ("short, signed or unsigned invalid for `%s'", name);
10171       else if (TREE_CODE (type) != INTEGER_TYPE)
10172         error ("long, short, signed or unsigned invalid for `%s'", name);
10173       else if (RIDBIT_SETP (RID_LONG, specbits)
10174                && RIDBIT_SETP (RID_SHORT, specbits))
10175         error ("long and short specified together for `%s'", name);
10176       else if ((RIDBIT_SETP (RID_LONG, specbits)
10177                 || RIDBIT_SETP (RID_SHORT, specbits))
10178                && explicit_char)
10179         error ("long or short specified with char for `%s'", name);
10180       else if ((RIDBIT_SETP (RID_LONG, specbits)
10181                 || RIDBIT_SETP (RID_SHORT, specbits))
10182                && TREE_CODE (type) == REAL_TYPE)
10183         error ("long or short specified with floating type for `%s'", name);
10184       else if (RIDBIT_SETP (RID_SIGNED, specbits)
10185                && RIDBIT_SETP (RID_UNSIGNED, specbits))
10186         error ("signed and unsigned given together for `%s'", name);
10187       else
10188         {
10189           ok = 1;
10190           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
10191             {
10192               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10193                        name);
10194               if (flag_pedantic_errors)
10195                 ok = 0;
10196             }
10197         }
10198
10199       /* Discard the type modifiers if they are invalid.  */
10200       if (! ok)
10201         {
10202           RIDBIT_RESET (RID_UNSIGNED, specbits);
10203           RIDBIT_RESET (RID_SIGNED, specbits);
10204           RIDBIT_RESET (RID_LONG, specbits);
10205           RIDBIT_RESET (RID_SHORT, specbits);
10206           longlong = 0;
10207         }
10208     }
10209
10210   if (RIDBIT_SETP (RID_COMPLEX, specbits)
10211       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
10212     {
10213       error ("complex invalid for `%s'", name);
10214       RIDBIT_RESET (RID_COMPLEX, specbits);
10215     }
10216
10217   /* Decide whether an integer type is signed or not.
10218      Optionally treat bitfields as signed by default.  */
10219   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10220       /* [class.bit]
10221
10222          It is implementation-defined whether a plain (neither
10223          explicitly signed or unsigned) char, short, int, or long
10224          bit-field is signed or unsigned.
10225
10226          Naturally, we extend this to long long as well.  Note that
10227          this does not include wchar_t.  */
10228       || (bitfield && !flag_signed_bitfields
10229           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
10230           /* A typedef for plain `int' without `signed' can be
10231              controlled just like plain `int', but a typedef for
10232              `signed int' cannot be so controlled.  */
10233           && !(typedef_decl
10234                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
10235           && (TREE_CODE (type) == INTEGER_TYPE
10236               || TREE_CODE (type) == CHAR_TYPE)
10237           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
10238     {
10239       if (longlong)
10240         type = long_long_unsigned_type_node;
10241       else if (RIDBIT_SETP (RID_LONG, specbits))
10242         type = long_unsigned_type_node;
10243       else if (RIDBIT_SETP (RID_SHORT, specbits))
10244         type = short_unsigned_type_node;
10245       else if (type == char_type_node)
10246         type = unsigned_char_type_node;
10247       else if (typedef_decl)
10248         type = unsigned_type (type);
10249       else
10250         type = unsigned_type_node;
10251     }
10252   else if (RIDBIT_SETP (RID_SIGNED, specbits)
10253            && type == char_type_node)
10254     type = signed_char_type_node;
10255   else if (longlong)
10256     type = long_long_integer_type_node;
10257   else if (RIDBIT_SETP (RID_LONG, specbits))
10258     type = long_integer_type_node;
10259   else if (RIDBIT_SETP (RID_SHORT, specbits))
10260     type = short_integer_type_node;
10261
10262   if (RIDBIT_SETP (RID_COMPLEX, specbits))
10263     {
10264       /* If we just have "complex", it is equivalent to
10265          "complex double", but if any modifiers at all are specified it is
10266          the complex form of TYPE.  E.g, "complex short" is
10267          "complex short int".  */
10268
10269       if (defaulted_int && ! longlong
10270           && ! (RIDBIT_SETP (RID_LONG, specbits)
10271                 || RIDBIT_SETP (RID_SHORT, specbits)
10272                 || RIDBIT_SETP (RID_SIGNED, specbits)
10273                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
10274         type = complex_double_type_node;
10275       else if (type == integer_type_node)
10276         type = complex_integer_type_node;
10277       else if (type == float_type_node)
10278         type = complex_float_type_node;
10279       else if (type == double_type_node)
10280         type = complex_double_type_node;
10281       else if (type == long_double_type_node)
10282         type = complex_long_double_type_node;
10283       else
10284         type = build_complex_type (type);
10285     }
10286
10287   if (sfk == sfk_conversion
10288       && (RIDBIT_SETP (RID_CONST, specbits)
10289           || RIDBIT_SETP (RID_VOLATILE, specbits)
10290           || RIDBIT_SETP (RID_RESTRICT, specbits)))
10291     cp_error ("qualifiers are not allowed on declaration of `operator %T'",
10292               ctor_return_type);
10293
10294   /* Set CONSTP if this declaration is `const', whether by
10295      explicit specification or via a typedef.
10296      Likewise for VOLATILEP.  */
10297
10298   constp = !! RIDBIT_SETP (RID_CONST, specbits) + CP_TYPE_CONST_P (type);
10299   restrictp =
10300     !! RIDBIT_SETP (RID_RESTRICT, specbits) + CP_TYPE_RESTRICT_P (type);
10301   volatilep =
10302     !! RIDBIT_SETP (RID_VOLATILE, specbits) + CP_TYPE_VOLATILE_P (type);
10303   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10304                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10305                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10306   type = cp_build_qualified_type (type, type_quals);
10307   staticp = 0;
10308   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
10309   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
10310   RIDBIT_RESET (RID_VIRTUAL, specbits);
10311   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
10312   RIDBIT_RESET (RID_EXPLICIT, specbits);
10313
10314   if (RIDBIT_SETP (RID_STATIC, specbits))
10315     staticp = 1 + (decl_context == FIELD);
10316
10317   if (virtualp && staticp == 2)
10318     {
10319       cp_error ("member `%D' cannot be declared both virtual and static",
10320                 dname);
10321       staticp = 0;
10322     }
10323   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
10324   RIDBIT_RESET (RID_FRIEND, specbits);
10325
10326   /* Warn if two storage classes are given. Default to `auto'.  */
10327
10328   if (RIDBIT_ANY_SET (specbits))
10329     {
10330       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
10331       if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
10332       if (decl_context == PARM && nclasses > 0)
10333         error ("storage class specifiers invalid in parameter declarations");
10334       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10335         {
10336           if (decl_context == PARM)
10337             error ("typedef declaration invalid in parameter declaration");
10338           nclasses++;
10339         }
10340       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
10341       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
10342     }
10343
10344   /* Give error if `virtual' is used outside of class declaration.  */
10345   if (virtualp
10346       && (current_class_name == NULL_TREE || decl_context != FIELD))
10347     {
10348       error ("virtual outside class declaration");
10349       virtualp = 0;
10350     }
10351
10352   /* Static anonymous unions are dealt with here.  */
10353   if (staticp && decl_context == TYPENAME
10354       && TREE_CODE (declspecs) == TREE_LIST
10355       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
10356     decl_context = FIELD;
10357
10358   /* Warn about storage classes that are invalid for certain
10359      kinds of declarations (parameters, typenames, etc.).  */
10360
10361   if (nclasses > 1)
10362     error ("multiple storage classes in declaration of `%s'", name);
10363   else if (decl_context != NORMAL && nclasses > 0)
10364     {
10365       if ((decl_context == PARM || decl_context == CATCHPARM)
10366           && (RIDBIT_SETP (RID_REGISTER, specbits)
10367               || RIDBIT_SETP (RID_AUTO, specbits)))
10368         ;
10369       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10370         ;
10371       else if (decl_context == FIELD
10372                /* C++ allows static class elements  */
10373                && RIDBIT_SETP (RID_STATIC, specbits))
10374         /* C++ also allows inlines and signed and unsigned elements,
10375            but in those cases we don't come in here.  */
10376         ;
10377       else
10378         {
10379           if (decl_context == FIELD)
10380             {
10381               tree tmp = NULL_TREE;
10382               register int op = 0;
10383
10384               if (declarator)
10385                 {
10386                   /* Avoid trying to get an operand off an identifier node.  */
10387                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10388                     tmp = declarator;
10389                   else
10390                     tmp = TREE_OPERAND (declarator, 0);
10391                   op = IDENTIFIER_OPNAME_P (tmp);
10392                   if (IDENTIFIER_TYPENAME_P (tmp))
10393                     {
10394                       if (IDENTIFIER_GLOBAL_VALUE (tmp)
10395                           && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (tmp))
10396                               == TYPE_DECL))
10397                         name = IDENTIFIER_POINTER (tmp);
10398                       else
10399                         name = "<invalid operator>";
10400                     }
10401                 }
10402               error ("storage class specified for %s `%s'",
10403                      op ? "member operator" : "field",
10404                      name);
10405             }
10406           else
10407             {
10408               if (decl_context == PARM || decl_context == CATCHPARM)
10409                 error ("storage class specified for parameter `%s'", name);
10410               else
10411                 error ("storage class specified for typename");
10412             }
10413           RIDBIT_RESET (RID_REGISTER, specbits);
10414           RIDBIT_RESET (RID_AUTO, specbits);
10415           RIDBIT_RESET (RID_EXTERN, specbits);
10416         }
10417     }
10418   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10419     {
10420       if (toplevel_bindings_p ())
10421         {
10422           /* It's common practice (and completely valid) to have a const
10423              be initialized and declared extern.  */
10424           if (!(type_quals & TYPE_QUAL_CONST))
10425             warning ("`%s' initialized and declared `extern'", name);
10426         }
10427       else
10428         error ("`%s' has both `extern' and initializer", name);
10429     }
10430   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10431            && ! toplevel_bindings_p ())
10432     error ("nested function `%s' declared `extern'", name);
10433   else if (toplevel_bindings_p ())
10434     {
10435       if (RIDBIT_SETP (RID_AUTO, specbits))
10436         error ("top-level declaration of `%s' specifies `auto'", name);
10437     }
10438
10439   if (nclasses > 0 && friendp)
10440     error ("storage class specifiers invalid in friend function declarations");
10441
10442   /* Now figure out the structure of the declarator proper.
10443      Descend through it, creating more complex types, until we reach
10444      the declared identifier (or NULL_TREE, in an absolute declarator).  */
10445
10446   inner_attrs = NULL_TREE;
10447   ignore_attrs = 0;
10448
10449   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10450          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10451     {
10452       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10453          an INDIRECT_REF (for *...),
10454          a CALL_EXPR (for ...(...)),
10455          an identifier (for the name being declared)
10456          or a null pointer (for the place in an absolute declarator
10457          where the name was omitted).
10458          For the last two cases, we have just exited the loop.
10459
10460          For C++ it could also be
10461          a SCOPE_REF (for class :: ...).  In this case, we have converted
10462          sensible names to types, and those are the values we use to
10463          qualify the member name.
10464          an ADDR_EXPR (for &...),
10465          a BIT_NOT_EXPR (for destructors)
10466
10467          At this point, TYPE is the type of elements of an array,
10468          or for a function to return, or for a pointer to point to.
10469          After this sequence of ifs, TYPE is the type of the
10470          array or function or pointer, and DECLARATOR has had its
10471          outermost layer removed.  */
10472
10473       if (type == error_mark_node)
10474         {
10475           if (TREE_CODE (declarator) == SCOPE_REF)
10476             declarator = TREE_OPERAND (declarator, 1);
10477           else
10478             declarator = TREE_OPERAND (declarator, 0);
10479           continue;
10480         }
10481       if (quals != NULL_TREE
10482           && (declarator == NULL_TREE
10483               || TREE_CODE (declarator) != SCOPE_REF))
10484         {
10485           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10486             ctype = TYPE_METHOD_BASETYPE (type);
10487           if (ctype != NULL_TREE)
10488             {
10489               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10490               grok_method_quals (ctype, dummy, quals);
10491               type = TREE_TYPE (dummy);
10492               ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
10493               quals = NULL_TREE;
10494             }
10495         }
10496
10497       /* See the comment for the TREE_LIST case, below.  */
10498       if (ignore_attrs)
10499         ignore_attrs = 0;
10500       else if (inner_attrs)
10501         {
10502           decl_attributes (type, inner_attrs, NULL_TREE);
10503           inner_attrs = NULL_TREE;
10504         }
10505
10506       switch (TREE_CODE (declarator))
10507         {
10508         case TREE_LIST:
10509           {
10510             /* We encode a declarator with embedded attributes using
10511                a TREE_LIST.  The attributes apply to the declarator
10512                directly inside them, so we have to skip an iteration
10513                before applying them to the type.  If the declarator just
10514                inside is the declarator-id, we apply the attrs to the
10515                decl itself.  */
10516             inner_attrs = TREE_PURPOSE (declarator);
10517             ignore_attrs = 1;
10518             declarator = TREE_VALUE (declarator);
10519           }
10520           break;
10521
10522         case ARRAY_REF:
10523           {
10524             register tree size;
10525
10526             size = TREE_OPERAND (declarator, 1);
10527
10528             /* VC++ spells a zero-sized array with [].  */
10529             if (size == NULL_TREE && decl_context == FIELD && ! staticp
10530                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10531               size = integer_zero_node;
10532
10533             declarator = TREE_OPERAND (declarator, 0);
10534
10535             type = create_array_type_for_decl (dname, type, size);
10536
10537             /* VLAs never work as fields. */
10538             if (decl_context == FIELD && !processing_template_decl
10539                 && TREE_CODE (type) == ARRAY_TYPE
10540                 && TYPE_DOMAIN (type) != NULL_TREE
10541                 && !TREE_CONSTANT (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
10542               {
10543                 cp_error ("size of member `%D' is not constant", dname);
10544                 /* Proceed with arbitrary constant size, so that offset
10545                    computations don't get confused. */
10546                 type = create_array_type_for_decl (dname, TREE_TYPE (type),
10547                                                    integer_one_node);
10548               }
10549
10550             ctype = NULL_TREE;
10551           }
10552           break;
10553
10554         case CALL_EXPR:
10555           {
10556             tree arg_types;
10557             int funcdecl_p;
10558             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10559             tree inner_decl = TREE_OPERAND (declarator, 0);
10560
10561             /* Declaring a function type.
10562                Make sure we have a valid type for the function to return.  */
10563
10564             /* We now know that the TYPE_QUALS don't apply to the
10565                decl, but to its return type.  */
10566             type_quals = TYPE_UNQUALIFIED;
10567
10568             /* Warn about some types functions can't return.  */
10569
10570             if (TREE_CODE (type) == FUNCTION_TYPE)
10571               {
10572                 error ("`%s' declared as function returning a function", name);
10573                 type = integer_type_node;
10574               }
10575             if (TREE_CODE (type) == ARRAY_TYPE)
10576               {
10577                 error ("`%s' declared as function returning an array", name);
10578                 type = integer_type_node;
10579               }
10580
10581             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10582               inner_decl = TREE_OPERAND (inner_decl, 1);
10583
10584             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10585               inner_decl = dname;
10586
10587             /* Pick up type qualifiers which should be applied to `this'.  */
10588             quals = CALL_DECLARATOR_QUALS (declarator);
10589
10590             /* Pick up the exception specifications.  */
10591             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10592
10593             /* Say it's a definition only for the CALL_EXPR
10594                closest to the identifier.  */
10595             funcdecl_p
10596               = inner_decl
10597               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10598                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10599                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10600
10601             if (ctype == NULL_TREE
10602                 && decl_context == FIELD
10603                 && funcdecl_p
10604                 && (friendp == 0 || dname == current_class_name))
10605               ctype = current_class_type;
10606
10607             if (ctype && sfk == sfk_conversion)
10608               TYPE_HAS_CONVERSION (ctype) = 1;
10609             if (ctype && constructor_name (ctype) == dname)
10610               {
10611                 /* We are within a class's scope. If our declarator name
10612                    is the same as the class name, and we are defining
10613                    a function, then it is a constructor/destructor, and
10614                    therefore returns a void type.  */
10615
10616                 if (flags == DTOR_FLAG)
10617                   {
10618                     /* ISO C++ 12.4/2.  A destructor may not be
10619                        declared const or volatile.  A destructor may
10620                        not be static.  */
10621                     if (staticp == 2)
10622                       error ("destructor cannot be static member function");
10623                     if (quals)
10624                       {
10625                         cp_error ("destructors may not be `%s'",
10626                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10627                         quals = NULL_TREE;
10628                       }
10629                     if (decl_context == FIELD)
10630                       {
10631                         if (! member_function_or_else (ctype,
10632                                                        current_class_type,
10633                                                        flags))
10634                           return void_type_node;
10635                       }
10636                   }
10637                 else            /* It's a constructor.  */
10638                   {
10639                     if (explicitp == 1)
10640                       explicitp = 2;
10641                     /* ISO C++ 12.1.  A constructor may not be
10642                        declared const or volatile.  A constructor may
10643                        not be virtual.  A constructor may not be
10644                        static.  */
10645                     if (staticp == 2)
10646                       error ("constructor cannot be static member function");
10647                     if (virtualp)
10648                       {
10649                         pedwarn ("constructors cannot be declared virtual");
10650                         virtualp = 0;
10651                       }
10652                     if (quals)
10653                       {
10654                         cp_error ("constructors may not be `%s'",
10655                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10656                         quals = NULL_TREE;
10657                       }
10658                     {
10659                       RID_BIT_TYPE tmp_bits;
10660                       bcopy ((void*)&specbits, (void*)&tmp_bits, sizeof (RID_BIT_TYPE));
10661                       RIDBIT_RESET (RID_INLINE, tmp_bits);
10662                       RIDBIT_RESET (RID_STATIC, tmp_bits);
10663                       if (RIDBIT_ANY_SET (tmp_bits))
10664                         error ("return value type specifier for constructor ignored");
10665                     }
10666                     if (decl_context == FIELD)
10667                       {
10668                         if (! member_function_or_else (ctype,
10669                                                        current_class_type,
10670                                                        flags))
10671                           return void_type_node;
10672                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10673                         if (sfk != sfk_constructor)
10674                           return NULL_TREE;
10675                       }
10676                   }
10677                 if (decl_context == FIELD)
10678                   staticp = 0;
10679               }
10680             else if (friendp)
10681               {
10682                 if (initialized)
10683                   error ("can't initialize friend function `%s'", name);
10684                 if (virtualp)
10685                   {
10686                     /* Cannot be both friend and virtual.  */
10687                     error ("virtual functions cannot be friends");
10688                     RIDBIT_RESET (RID_FRIEND, specbits);
10689                     friendp = 0;
10690                   }
10691                 if (decl_context == NORMAL)
10692                   error ("friend declaration not in class definition");
10693                 if (current_function_decl && funcdef_flag)
10694                   cp_error ("can't define friend function `%s' in a local class definition",
10695                             name);
10696               }
10697
10698             /* Construct the function type and go to the next
10699                inner layer of declarator.  */
10700
10701             declarator = TREE_OPERAND (declarator, 0);
10702
10703             /* FIXME: This is where default args should be fully
10704                processed.  */
10705
10706             arg_types = grokparms (inner_parms, funcdecl_p ? funcdef_flag : 0);
10707
10708             if (declarator && flags == DTOR_FLAG)
10709               {
10710                 /* A destructor declared in the body of a class will
10711                    be represented as a BIT_NOT_EXPR.  But, we just
10712                    want the underlying IDENTIFIER.  */
10713                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10714                   declarator = TREE_OPERAND (declarator, 0);
10715
10716                 if (strict_prototype == 0 && arg_types == NULL_TREE)
10717                   arg_types = void_list_node;
10718                 else if (arg_types == NULL_TREE
10719                          || arg_types != void_list_node)
10720                   {
10721                     cp_error ("destructors may not have parameters");
10722                     arg_types = void_list_node;
10723                     last_function_parms = NULL_TREE;
10724                   }
10725               }
10726
10727             /* ANSI says that `const int foo ();'
10728                does not make the function foo const.  */
10729             type = build_function_type (type, arg_types);
10730
10731             {
10732               tree t;
10733               for (t = arg_types; t; t = TREE_CHAIN (t))
10734                 if (TREE_PURPOSE (t)
10735                     && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10736                   {
10737                     add_defarg_fn (type);
10738                     break;
10739                   }
10740             }
10741           }
10742           break;
10743
10744         case ADDR_EXPR:
10745         case INDIRECT_REF:
10746           /* Filter out pointers-to-references and references-to-references.
10747              We can get these if a TYPE_DECL is used.  */
10748
10749           if (TREE_CODE (type) == REFERENCE_TYPE)
10750             {
10751               error ("cannot declare %s to references",
10752                      TREE_CODE (declarator) == ADDR_EXPR
10753                      ? "references" : "pointers");
10754               declarator = TREE_OPERAND (declarator, 0);
10755               continue;
10756             }
10757
10758           if (TREE_CODE (type) == OFFSET_TYPE
10759               && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10760                   || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10761             {
10762               cp_error ("cannot declare pointer to `%#T' member",
10763                         TREE_TYPE (type));
10764               type = TREE_TYPE (type);
10765             }
10766
10767           /* Merge any constancy or volatility into the target type
10768              for the pointer.  */
10769
10770           /* We now know that the TYPE_QUALS don't apply to the decl,
10771              but to the target of the pointer.  */
10772           type_quals = TYPE_UNQUALIFIED;
10773
10774           if (TREE_CODE (declarator) == ADDR_EXPR)
10775             {
10776               if (TREE_CODE (type) == VOID_TYPE)
10777                 error ("invalid type: `void &'");
10778               else
10779                 type = build_reference_type (type);
10780             }
10781           else if (TREE_CODE (type) == METHOD_TYPE)
10782             type = build_ptrmemfunc_type (build_pointer_type (type));
10783           else
10784             type = build_pointer_type (type);
10785
10786           /* Process a list of type modifier keywords (such as
10787              const or volatile) that were given inside the `*' or `&'.  */
10788
10789           if (TREE_TYPE (declarator))
10790             {
10791               register tree typemodlist;
10792               int erred = 0;
10793
10794               constp = 0;
10795               volatilep = 0;
10796               restrictp = 0;
10797               for (typemodlist = TREE_TYPE (declarator); typemodlist;
10798                    typemodlist = TREE_CHAIN (typemodlist))
10799                 {
10800                   tree qualifier = TREE_VALUE (typemodlist);
10801
10802                   if (qualifier == ridpointers[(int) RID_CONST])
10803                     constp++;
10804                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
10805                     volatilep++;
10806                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
10807                     restrictp++;
10808                   else if (!erred)
10809                     {
10810                       erred = 1;
10811                       error ("invalid type modifier within pointer declarator");
10812                     }
10813                 }
10814               if (constp > 1)
10815                 pedwarn ("duplicate `const'");
10816               if (volatilep > 1)
10817                 pedwarn ("duplicate `volatile'");
10818               if (restrictp > 1)
10819                 pedwarn ("duplicate `restrict'");
10820
10821               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10822                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10823                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10824               if (TREE_CODE (declarator) == ADDR_EXPR
10825                   && (constp || volatilep))
10826                 {
10827                   if (constp)
10828                     pedwarn ("discarding `const' applied to a reference");
10829                   if (volatilep)
10830                     pedwarn ("discarding `volatile' applied to a reference");
10831                   type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
10832                 }
10833               type = cp_build_qualified_type (type, type_quals);
10834             }
10835           declarator = TREE_OPERAND (declarator, 0);
10836           ctype = NULL_TREE;
10837           break;
10838
10839         case SCOPE_REF:
10840           {
10841             /* We have converted type names to NULL_TREE if the
10842                name was bogus, or to a _TYPE node, if not.
10843
10844                The variable CTYPE holds the type we will ultimately
10845                resolve to.  The code here just needs to build
10846                up appropriate member types.  */
10847             tree sname = TREE_OPERAND (declarator, 1);
10848             tree t;
10849
10850             /* Destructors can have their visibilities changed as well.  */
10851             if (TREE_CODE (sname) == BIT_NOT_EXPR)
10852               sname = TREE_OPERAND (sname, 0);
10853
10854             if (TREE_COMPLEXITY (declarator) == 0)
10855               /* This needs to be here, in case we are called
10856                  multiple times.  */ ;
10857             else if (TREE_COMPLEXITY (declarator) == -1)
10858               /* Namespace member. */
10859               pop_decl_namespace ();
10860             else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
10861               /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10862             else if (! IS_AGGR_TYPE_CODE
10863                      (TREE_CODE (TREE_OPERAND (declarator, 0))))
10864               ;
10865             else if (TREE_COMPLEXITY (declarator) == current_class_depth)
10866               {
10867                 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10868                    that refer to ctype.  They couldn't be resolved earlier
10869                    because we hadn't pushed into the class yet.
10870                    Example: resolve 'B<T>::type' in
10871                    'B<typename B<T>::type> B<T>::f () { }'.  */
10872                 if (current_template_parms
10873                     && uses_template_parms (type)
10874                     && uses_template_parms (current_class_type))
10875                   {
10876                     tree args = current_template_args ();
10877                     type = tsubst (type, args, /*complain=*/1, NULL_TREE);
10878                   }
10879
10880                 /* This pop_nested_class corresponds to the
10881                    push_nested_class used to push into class scope for
10882                    parsing the argument list of a function decl, in
10883                    qualified_id.  */
10884                 pop_nested_class ();
10885                 TREE_COMPLEXITY (declarator) = current_class_depth;
10886               }
10887             else
10888               my_friendly_abort (16);
10889
10890             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
10891               {
10892                 /* We had a reference to a global decl, or
10893                    perhaps we were given a non-aggregate typedef,
10894                    in which case we cleared this out, and should just
10895                    keep going as though it wasn't there.  */
10896                 declarator = sname;
10897                 continue;
10898               }
10899             ctype = TREE_OPERAND (declarator, 0);
10900
10901             t = ctype;
10902             while (t != NULL_TREE && CLASS_TYPE_P (t))
10903               {
10904                 /* You're supposed to have one `template <...>'
10905                    for every template class, but you don't need one
10906                    for a full specialization.  For example:
10907
10908                      template <class T> struct S{};
10909                      template <> struct S<int> { void f(); };
10910                      void S<int>::f () {}
10911
10912                    is correct; there shouldn't be a `template <>' for
10913                    the definition of `S<int>::f'.  */
10914                 if (CLASSTYPE_TEMPLATE_INFO (t)
10915                     && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
10916                         || uses_template_parms (CLASSTYPE_TI_ARGS (t))))
10917                   template_count += 1;
10918
10919                 t = TYPE_MAIN_DECL (t);
10920                 if (DECL_LANG_SPECIFIC (t))
10921                   t = DECL_CONTEXT (t);
10922                 else
10923                   t = NULL_TREE;
10924               }
10925
10926             if (sname == NULL_TREE)
10927               goto done_scoping;
10928
10929             if (TREE_CODE (sname) == IDENTIFIER_NODE)
10930               {
10931                 /* This is the `standard' use of the scoping operator:
10932                    basetype :: member .  */
10933
10934                 if (ctype == current_class_type)
10935                   {
10936                     /* class A {
10937                          void A::f ();
10938                        };
10939
10940                        Is this ill-formed?  */
10941
10942                     if (pedantic)
10943                       cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10944                                   ctype, name);
10945                   }
10946                 else if (TREE_CODE (type) == FUNCTION_TYPE)
10947                   {
10948                     if (current_class_type == NULL_TREE
10949                         || friendp)
10950                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10951                                                       TYPE_ARG_TYPES (type));
10952                     else
10953                       {
10954                         cp_error ("cannot declare member function `%T::%s' within `%T'",
10955                                   ctype, name, current_class_type);
10956                         return void_type_node;
10957                       }
10958                   }
10959                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
10960                          || COMPLETE_TYPE_P (complete_type (ctype)))
10961                   {
10962                     /* Have to move this code elsewhere in this function.
10963                        this code is used for i.e., typedef int A::M; M *pm;
10964
10965                        It is?  How? jason 10/2/94 */
10966
10967                     if (current_class_type)
10968                       {
10969                         cp_error ("cannot declare member `%T::%s' within `%T'",
10970                                   ctype, name, current_class_type);
10971                         return void_type_node;
10972                       }
10973                     type = build_offset_type (ctype, type);
10974                   }
10975                 else if (uses_template_parms (ctype))
10976                   {
10977                     if (TREE_CODE (type) == FUNCTION_TYPE)
10978                       type
10979                         = build_cplus_method_type (ctype, TREE_TYPE (type),
10980                                                    TYPE_ARG_TYPES (type));
10981                   }
10982                 else
10983                   {
10984                     cp_error ("structure `%T' not yet defined", ctype);
10985                     return error_mark_node;
10986                   }
10987
10988                 declarator = sname;
10989               }
10990             else if (TREE_CODE (sname) == SCOPE_REF)
10991               my_friendly_abort (17);
10992             else
10993               {
10994               done_scoping:
10995                 declarator = TREE_OPERAND (declarator, 1);
10996                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
10997                   /* In this case, we will deal with it later.  */
10998                   ;
10999                 else
11000                   {
11001                     if (TREE_CODE (type) == FUNCTION_TYPE)
11002                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
11003                                                       TYPE_ARG_TYPES (type));
11004                     else
11005                       type = build_offset_type (ctype, type);
11006                   }
11007               }
11008           }
11009           break;
11010
11011         case BIT_NOT_EXPR:
11012           declarator = TREE_OPERAND (declarator, 0);
11013           break;
11014
11015         case RECORD_TYPE:
11016         case UNION_TYPE:
11017         case ENUMERAL_TYPE:
11018           declarator = NULL_TREE;
11019           break;
11020
11021         case ERROR_MARK:
11022           declarator = NULL_TREE;
11023           break;
11024
11025         default:
11026           my_friendly_abort (158);
11027         }
11028     }
11029
11030   /* See the comment for the TREE_LIST case, above.  */
11031   if (inner_attrs)
11032     {
11033       if (! ignore_attrs)
11034         decl_attributes (type, inner_attrs, NULL_TREE);
11035       else if (attrlist)
11036         TREE_VALUE (attrlist) = chainon (inner_attrs, TREE_VALUE (attrlist));
11037       else
11038         attrlist = build_decl_list (NULL_TREE, inner_attrs);
11039     }
11040
11041   /* Now TYPE has the actual type.  */
11042
11043   if (explicitp == 1 || (explicitp && friendp))
11044     {
11045       /* [dcl.fct.spec] The explicit specifier shall only be used in
11046          declarations of constructors within a class definition.  */
11047       error ("only declarations of constructors can be `explicit'");
11048       explicitp = 0;
11049     }
11050
11051   if (RIDBIT_SETP (RID_MUTABLE, specbits))
11052     {
11053       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
11054         {
11055           error ("non-member `%s' cannot be declared `mutable'", name);
11056           RIDBIT_RESET (RID_MUTABLE, specbits);
11057         }
11058       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
11059         {
11060           error ("non-object member `%s' cannot be declared `mutable'", name);
11061           RIDBIT_RESET (RID_MUTABLE, specbits);
11062         }
11063       else if (TREE_CODE (type) == FUNCTION_TYPE
11064                || TREE_CODE (type) == METHOD_TYPE)
11065         {
11066           error ("function `%s' cannot be declared `mutable'", name);
11067           RIDBIT_RESET (RID_MUTABLE, specbits);
11068         }
11069       else if (staticp)
11070         {
11071           error ("static `%s' cannot be declared `mutable'", name);
11072           RIDBIT_RESET (RID_MUTABLE, specbits);
11073         }
11074       else if (type_quals & TYPE_QUAL_CONST)
11075         {
11076           error ("const `%s' cannot be declared `mutable'", name);
11077           RIDBIT_RESET (RID_MUTABLE, specbits);
11078         }
11079     }
11080
11081   if (declarator == NULL_TREE
11082       || TREE_CODE (declarator) == IDENTIFIER_NODE
11083       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
11084           && (TREE_CODE (type) == FUNCTION_TYPE
11085               || TREE_CODE (type) == METHOD_TYPE)))
11086     /* OK */;
11087   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11088     {
11089       cp_error ("template-id `%D' used as a declarator", declarator);
11090       declarator = dname;
11091     }
11092   else
11093     /* Unexpected declarator format.  */
11094     my_friendly_abort (990210);
11095
11096   /* If this is declaring a typedef name, return a TYPE_DECL.  */
11097
11098   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
11099     {
11100       tree decl;
11101
11102       /* Note that the grammar rejects storage classes
11103          in typenames, fields or parameters.  */
11104       if (current_lang_name == lang_name_java)
11105         TYPE_FOR_JAVA (type) = 1;
11106
11107       if (decl_context == FIELD)
11108         {
11109           if (declarator == constructor_name (current_class_type))
11110             cp_pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
11111                         declarator);
11112           decl = build_lang_decl (TYPE_DECL, declarator, type);
11113         }
11114       else
11115         decl = build_decl (TYPE_DECL, declarator, type);
11116
11117       /* If the user declares "typedef struct {...} foo" then the
11118          struct will have an anonymous name.  Fill that name in now.
11119          Nothing can refer to it, so nothing needs know about the name
11120          change.  */
11121       if (type != error_mark_node
11122           && declarator
11123           && TYPE_NAME (type)
11124           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11125           && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type))
11126           && CP_TYPE_QUALS (type) == TYPE_UNQUALIFIED)
11127         {
11128           tree oldname = TYPE_NAME (type);
11129           tree t;
11130
11131           /* Replace the anonymous name with the real name everywhere.  */
11132           lookup_tag_reverse (type, declarator);
11133           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
11134             if (TYPE_NAME (t) == oldname)
11135               TYPE_NAME (t) = decl;
11136
11137           if (TYPE_LANG_SPECIFIC (type))
11138             TYPE_WAS_ANONYMOUS (type) = 1;
11139
11140           /* If this is a typedef within a template class, the nested
11141              type is a (non-primary) template.  The name for the
11142              template needs updating as well.  */
11143           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
11144             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
11145               = TYPE_IDENTIFIER (type);
11146
11147           if (flag_new_abi)
11148             DECL_ASSEMBLER_NAME (decl) = mangle_type (type);
11149           else
11150             {
11151               /* XXX Temporarily set the scope.
11152                  When returning, start_decl expects it as NULL_TREE,
11153                  and will then then set it using pushdecl. */
11154               my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 980404);
11155               if (current_class_type)
11156                 DECL_CONTEXT (decl) = current_class_type;
11157               else
11158                 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
11159
11160               DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
11161               DECL_ASSEMBLER_NAME (decl)
11162                 = get_identifier (build_overload_name (type, 1, 1));
11163               DECL_CONTEXT (decl) = NULL_TREE;
11164             }
11165
11166           /* FIXME remangle member functions; member functions of a
11167              type with external linkage have external linkage.  */
11168         }
11169
11170       if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
11171         {
11172           cp_error_at ("typedef name may not be class-qualified", decl);
11173           return NULL_TREE;
11174         }
11175       else if (quals)
11176         {
11177           if (ctype == NULL_TREE)
11178             {
11179               if (TREE_CODE (type) != METHOD_TYPE)
11180                 cp_error_at ("invalid type qualifier for non-member function type", decl);
11181               else
11182                 ctype = TYPE_METHOD_BASETYPE (type);
11183             }
11184           if (ctype != NULL_TREE)
11185             grok_method_quals (ctype, decl, quals);
11186         }
11187
11188       if (RIDBIT_SETP (RID_SIGNED, specbits)
11189           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
11190         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
11191
11192       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
11193                       inlinep, friendp, raises != NULL_TREE);
11194
11195       if (initialized)
11196         error ("typedef declaration includes an initializer");
11197
11198       return decl;
11199     }
11200
11201   /* Detect the case of an array type of unspecified size
11202      which came, as such, direct from a typedef name.
11203      We must copy the type, so that each identifier gets
11204      a distinct type, so that each identifier's size can be
11205      controlled separately by its own initializer.  */
11206
11207   if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
11208       && TYPE_DOMAIN (type) == NULL_TREE)
11209     {
11210       type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
11211     }
11212
11213   /* If this is a type name (such as, in a cast or sizeof),
11214      compute the type and return it now.  */
11215
11216   if (decl_context == TYPENAME)
11217     {
11218       /* Note that the grammar rejects storage classes
11219          in typenames, fields or parameters.  */
11220       if (type_quals != TYPE_UNQUALIFIED)
11221         type_quals = TYPE_UNQUALIFIED;
11222
11223       /* Special case: "friend class foo" looks like a TYPENAME context.  */
11224       if (friendp)
11225         {
11226           if (type_quals != TYPE_UNQUALIFIED)
11227             {
11228               cp_error ("type qualifiers specified for friend class declaration");
11229               type_quals = TYPE_UNQUALIFIED;
11230             }
11231           if (inlinep)
11232             {
11233               cp_error ("`inline' specified for friend class declaration");
11234               inlinep = 0;
11235             }
11236
11237           /* Only try to do this stuff if we didn't already give up.  */
11238           if (type != integer_type_node)
11239             {
11240               /* A friendly class?  */
11241               if (current_class_type)
11242                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
11243               else
11244                 error ("trying to make class `%s' a friend of global scope",
11245                        TYPE_NAME_STRING (type));
11246               type = void_type_node;
11247             }
11248         }
11249       else if (quals)
11250         {
11251           if (ctype == NULL_TREE)
11252             {
11253               if (TREE_CODE (type) != METHOD_TYPE)
11254                 cp_error ("invalid qualifiers on non-member function type");
11255               else
11256                 ctype = TYPE_METHOD_BASETYPE (type);
11257             }
11258           if (ctype)
11259             {
11260               tree dummy = build_decl (TYPE_DECL, declarator, type);
11261               grok_method_quals (ctype, dummy, quals);
11262               type = TREE_TYPE (dummy);
11263             }
11264         }
11265
11266       return type;
11267     }
11268   else if (declarator == NULL_TREE && decl_context != PARM
11269            && decl_context != CATCHPARM
11270            && TREE_CODE (type) != UNION_TYPE
11271            && ! bitfield)
11272     {
11273       cp_error ("abstract declarator `%T' used as declaration", type);
11274       declarator = make_anon_name ();
11275     }
11276
11277   /* `void' at top level (not within pointer)
11278      is allowed only in typedefs or type names.
11279      We don't complain about parms either, but that is because
11280      a better error message can be made later.  */
11281
11282   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
11283     {
11284       if (! declarator)
11285         error ("unnamed variable or field declared void");
11286       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
11287         {
11288           if (IDENTIFIER_OPNAME_P (declarator))
11289             my_friendly_abort (356);
11290           else
11291             error ("variable or field `%s' declared void", name);
11292         }
11293       else
11294         error ("variable or field declared void");
11295       type = integer_type_node;
11296     }
11297
11298   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11299      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
11300
11301   if (decl_context == PARM || decl_context == CATCHPARM)
11302     {
11303       if (ctype || in_namespace)
11304         error ("cannot use `::' in parameter declaration");
11305
11306       /* A parameter declared as an array of T is really a pointer to T.
11307          One declared as a function is really a pointer to a function.
11308          One declared as a member is really a pointer to member.  */
11309
11310       if (TREE_CODE (type) == ARRAY_TYPE)
11311         {
11312           /* Transfer const-ness of array into that of type pointed to.  */
11313           type = build_pointer_type (TREE_TYPE (type));
11314           type_quals = TYPE_UNQUALIFIED;
11315         }
11316       else if (TREE_CODE (type) == FUNCTION_TYPE)
11317         type = build_pointer_type (type);
11318       else if (TREE_CODE (type) == OFFSET_TYPE)
11319         type = build_pointer_type (type);
11320       else if (TREE_CODE (type) == VOID_TYPE && declarator)
11321         {
11322           error ("declaration of `%s' as void", name);
11323           return NULL_TREE;
11324         }
11325     }
11326
11327   {
11328     register tree decl;
11329
11330     if (decl_context == PARM)
11331       {
11332         decl = build_decl (PARM_DECL, declarator, type);
11333
11334         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
11335                         inlinep, friendp, raises != NULL_TREE);
11336
11337         /* Compute the type actually passed in the parmlist,
11338            for the case where there is no prototype.
11339            (For example, shorts and chars are passed as ints.)
11340            When there is a prototype, this is overridden later.  */
11341
11342         DECL_ARG_TYPE (decl) = type_promotes_to (type);
11343       }
11344     else if (decl_context == FIELD)
11345       {
11346         if (type == error_mark_node)
11347           {
11348             /* Happens when declaring arrays of sizes which
11349                are error_mark_node, for example.  */
11350             decl = NULL_TREE;
11351           }
11352         else if (in_namespace && !friendp)
11353           {
11354             /* Something like struct S { int N::j; };  */
11355             cp_error ("invalid use of `::'");
11356             decl = NULL_TREE;
11357           }
11358         else if (TREE_CODE (type) == FUNCTION_TYPE)
11359           {
11360             int publicp = 0;
11361             tree function_context;
11362
11363             /* We catch the others as conflicts with the builtin
11364                typedefs.  */
11365             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11366               {
11367                 cp_error ("function `%D' cannot be declared friend",
11368                           declarator);
11369                 friendp = 0;
11370               }
11371
11372             if (friendp == 0)
11373               {
11374                 if (ctype == NULL_TREE)
11375                   ctype = current_class_type;
11376
11377                 if (ctype == NULL_TREE)
11378                   {
11379                     cp_error ("can't make `%D' into a method -- not in a class",
11380                               declarator);
11381                     return void_type_node;
11382                   }
11383
11384                 /* ``A union may [ ... ] not [ have ] virtual functions.''
11385                    ARM 9.5 */
11386                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11387                   {
11388                     cp_error ("function `%D' declared virtual inside a union",
11389                               declarator);
11390                     return void_type_node;
11391                   }
11392
11393                 if (declarator == ansi_opname (NEW_EXPR)
11394                     || declarator == ansi_opname (VEC_NEW_EXPR)
11395                     || declarator == ansi_opname (DELETE_EXPR)
11396                     || declarator == ansi_opname (VEC_DELETE_EXPR))
11397                   {
11398                     if (virtualp)
11399                       {
11400                         cp_error ("`%D' cannot be declared virtual, since it is always static",
11401                                   declarator);
11402                         virtualp = 0;
11403                       }
11404                   }
11405                 else if (staticp < 2)
11406                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11407                                                   TYPE_ARG_TYPES (type));
11408               }
11409
11410             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
11411             function_context = (ctype != NULL_TREE) ?
11412               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11413             publicp = (! friendp || ! staticp)
11414               && function_context == NULL_TREE;
11415             decl = grokfndecl (ctype, type,
11416                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11417                                ? declarator : dname,
11418                                declarator,
11419                                virtualp, flags, quals, raises,
11420                                friendp ? -1 : 0, friendp, publicp, inlinep,
11421                                funcdef_flag, template_count, in_namespace);
11422             if (decl == NULL_TREE)
11423               return decl;
11424 #if 0
11425             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
11426             /* The decl and setting of decl_machine_attr is also turned off.  */
11427             decl = build_decl_attribute_variant (decl, decl_machine_attr);
11428 #endif
11429
11430             /* [class.conv.ctor]
11431
11432                A constructor declared without the function-specifier
11433                explicit that can be called with a single parameter
11434                specifies a conversion from the type of its first
11435                parameter to the type of its class.  Such a constructor
11436                is called a converting constructor.  */
11437             if (explicitp == 2)
11438               DECL_NONCONVERTING_P (decl) = 1;
11439             else if (DECL_CONSTRUCTOR_P (decl))
11440               {
11441                 /* The constructor can be called with exactly one
11442                    parameter if there is at least one parameter, and
11443                    any subsequent parameters have default arguments.
11444                    We don't look at the first parameter, which is
11445                    really just the `this' parameter for the new
11446                    object.  */
11447                 tree arg_types =
11448                   TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)));
11449
11450                 /* Skip the `in_chrg' argument too, if present.  */
11451                 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
11452                   arg_types = TREE_CHAIN (arg_types);
11453
11454                 if (arg_types == void_list_node
11455                     || (arg_types
11456                         && TREE_CHAIN (arg_types)
11457                         && TREE_CHAIN (arg_types) != void_list_node
11458                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11459                   DECL_NONCONVERTING_P (decl) = 1;
11460               }
11461           }
11462         else if (TREE_CODE (type) == METHOD_TYPE)
11463           {
11464             /* We only get here for friend declarations of
11465                members of other classes.  */
11466             /* All method decls are public, so tell grokfndecl to set
11467                TREE_PUBLIC, also.  */
11468             decl = grokfndecl (ctype, type, declarator, declarator,
11469                                virtualp, flags, quals, raises,
11470                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11471                                template_count, in_namespace);
11472             if (decl == NULL_TREE)
11473               return NULL_TREE;
11474           }
11475         else if (!staticp && ! processing_template_decl
11476                  && !COMPLETE_TYPE_P (complete_type (type))
11477                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11478           {
11479             if (declarator)
11480               cp_error ("field `%D' has incomplete type", declarator);
11481             else
11482               cp_error ("name `%T' has incomplete type", type);
11483
11484             /* If we're instantiating a template, tell them which
11485                instantiation made the field's type be incomplete.  */
11486             if (current_class_type
11487                 && TYPE_NAME (current_class_type)
11488                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11489                 && declspecs && TREE_VALUE (declspecs)
11490                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11491               cp_error ("  in instantiation of template `%T'",
11492                         current_class_type);
11493
11494             type = error_mark_node;
11495             decl = NULL_TREE;
11496           }
11497         else
11498           {
11499             if (friendp)
11500               {
11501                 error ("`%s' is neither function nor member function; cannot be declared friend",
11502                        IDENTIFIER_POINTER (declarator));
11503                 friendp = 0;
11504               }
11505             decl = NULL_TREE;
11506           }
11507
11508         if (friendp)
11509           {
11510             /* Friends are treated specially.  */
11511             if (ctype == current_class_type)
11512               warning ("member functions are implicitly friends of their class");
11513             else
11514               {
11515                 tree t = NULL_TREE;
11516                 if (decl && DECL_NAME (decl))
11517                   {
11518                     if (template_class_depth (current_class_type) == 0)
11519                       {
11520                         decl
11521                           = check_explicit_specialization
11522                           (declarator, decl,
11523                            template_count, 2 * (funcdef_flag != 0) + 4);
11524                         if (decl == error_mark_node)
11525                           return error_mark_node;
11526                       }
11527
11528                     t = do_friend (ctype, declarator, decl,
11529                                    last_function_parms, attrlist, flags, quals,
11530                                    funcdef_flag);
11531                   }
11532                 if (t && funcdef_flag)
11533                   return t;
11534
11535                 return void_type_node;
11536               }
11537           }
11538
11539         /* Structure field.  It may not be a function, except for C++ */
11540
11541         if (decl == NULL_TREE)
11542           {
11543             if (initialized)
11544               {
11545                 if (!staticp)
11546                   {
11547                     /* An attempt is being made to initialize a non-static
11548                        member.  But, from [class.mem]:
11549
11550                        4 A member-declarator can contain a
11551                        constant-initializer only if it declares a static
11552                        member (_class.static_) of integral or enumeration
11553                        type, see _class.static.data_.
11554
11555                        This used to be relatively common practice, but
11556                        the rest of the compiler does not correctly
11557                        handle the initialization unless the member is
11558                        static so we make it static below.  */
11559                     cp_pedwarn ("ISO C++ forbids initialization of member `%D'",
11560                                 declarator);
11561                     cp_pedwarn ("making `%D' static", declarator);
11562                     staticp = 1;
11563                   }
11564
11565                 if (uses_template_parms (type))
11566                   /* We'll check at instantiation time.  */
11567                   ;
11568                 else if (check_static_variable_definition (declarator,
11569                                                            type))
11570                   /* If we just return the declaration, crashes
11571                      will sometimes occur.  We therefore return
11572                      void_type_node, as if this was a friend
11573                      declaration, to cause callers to completely
11574                      ignore this declaration.  */
11575                   return void_type_node;
11576               }
11577
11578             /* 9.2p13 [class.mem] */
11579             if (declarator == constructor_name (current_class_type)
11580                 /* The standard does not allow non-static data members
11581                    here either, but we agreed at the 10/99 meeting
11582                    to change that in TC 1 so that they are allowed in
11583                    classes with no user-defined constructors.  */
11584                 && staticp)
11585               cp_pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
11586                           declarator);
11587
11588             if (staticp)
11589               {
11590                 /* C++ allows static class members.  All other work
11591                    for this is done by grokfield.  */
11592                 decl = build_lang_decl (VAR_DECL, declarator, type);
11593                 TREE_STATIC (decl) = 1;
11594                 /* In class context, 'static' means public access.  */
11595                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11596               }
11597             else
11598               {
11599                 decl = build_decl (FIELD_DECL, declarator, type);
11600                 DECL_NONADDRESSABLE_P (decl) = bitfield;
11601                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11602                   {
11603                     DECL_MUTABLE_P (decl) = 1;
11604                     RIDBIT_RESET (RID_MUTABLE, specbits);
11605                   }
11606               }
11607
11608             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11609                             inlinep, friendp, raises != NULL_TREE);
11610           }
11611       }
11612     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11613       {
11614         tree original_name;
11615         int publicp = 0;
11616
11617         if (! declarator)
11618           return NULL_TREE;
11619
11620         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11621           original_name = dname;
11622         else
11623           original_name = declarator;
11624
11625         if (RIDBIT_SETP (RID_AUTO, specbits))
11626           error ("storage class `auto' invalid for function `%s'", name);
11627         else if (RIDBIT_SETP (RID_REGISTER, specbits))
11628           error ("storage class `register' invalid for function `%s'", name);
11629
11630         /* Function declaration not at top level.
11631            Storage classes other than `extern' are not allowed
11632            and `extern' makes no difference.  */
11633         if (! toplevel_bindings_p ()
11634             && (RIDBIT_SETP (RID_STATIC, specbits)
11635                 || RIDBIT_SETP (RID_INLINE, specbits))
11636             && pedantic)
11637           {
11638             if (RIDBIT_SETP (RID_STATIC, specbits))
11639               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11640             else
11641               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11642           }
11643
11644         if (ctype == NULL_TREE)
11645           {
11646             if (virtualp)
11647               {
11648                 error ("virtual non-class function `%s'", name);
11649                 virtualp = 0;
11650               }
11651           }
11652         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11653           type = build_cplus_method_type (ctype, TREE_TYPE (type),
11654                                           TYPE_ARG_TYPES (type));
11655
11656         /* Record presence of `static'.  */
11657         publicp = (ctype != NULL_TREE
11658                    || RIDBIT_SETP (RID_EXTERN, specbits)
11659                    || !RIDBIT_SETP (RID_STATIC, specbits));
11660
11661         decl = grokfndecl (ctype, type, original_name, declarator,
11662                            virtualp, flags, quals, raises,
11663                            1, friendp,
11664                            publicp, inlinep, funcdef_flag,
11665                            template_count, in_namespace);
11666         if (decl == NULL_TREE)
11667           return NULL_TREE;
11668
11669         if (staticp == 1)
11670           {
11671             int illegal_static = 0;
11672
11673             /* Don't allow a static member function in a class, and forbid
11674                declaring main to be static.  */
11675             if (TREE_CODE (type) == METHOD_TYPE)
11676               {
11677                 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11678                 illegal_static = 1;
11679               }
11680             else if (current_function_decl)
11681               {
11682                 /* FIXME need arm citation */
11683                 error ("cannot declare static function inside another function");
11684                 illegal_static = 1;
11685               }
11686
11687             if (illegal_static)
11688               {
11689                 staticp = 0;
11690                 RIDBIT_RESET (RID_STATIC, specbits);
11691               }
11692           }
11693       }
11694     else
11695       {
11696         /* It's a variable.  */
11697
11698         /* An uninitialized decl with `extern' is a reference.  */
11699         decl = grokvardecl (type, declarator, &specbits,
11700                             initialized,
11701                             (type_quals & TYPE_QUAL_CONST) != 0,
11702                             in_namespace);
11703         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11704                         inlinep, friendp, raises != NULL_TREE);
11705
11706         if (ctype)
11707           {
11708             DECL_CONTEXT (decl) = ctype;
11709             if (staticp == 1)
11710               {
11711                 cp_pedwarn ("static member `%D' re-declared as static", decl);
11712                 staticp = 0;
11713                 RIDBIT_RESET (RID_STATIC, specbits);
11714               }
11715             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11716               {
11717                 cp_error ("static member `%D' declared `register'", decl);
11718                 RIDBIT_RESET (RID_REGISTER, specbits);
11719               }
11720             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11721               {
11722                 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11723                             decl);
11724                 RIDBIT_RESET (RID_EXTERN, specbits);
11725               }
11726           }
11727       }
11728
11729     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11730
11731     /* Record `register' declaration for warnings on &
11732        and in case doing stupid register allocation.  */
11733
11734     if (RIDBIT_SETP (RID_REGISTER, specbits))
11735       DECL_REGISTER (decl) = 1;
11736
11737     if (RIDBIT_SETP (RID_EXTERN, specbits))
11738       DECL_THIS_EXTERN (decl) = 1;
11739
11740     if (RIDBIT_SETP (RID_STATIC, specbits))
11741       DECL_THIS_STATIC (decl) = 1;
11742
11743     /* Record constancy and volatility.  There's no need to do this
11744        when processing a template; we'll do this for the instantiated
11745        declaration based on the type of DECL.  */
11746     if (!processing_template_decl)
11747       c_apply_type_quals_to_decl (type_quals, decl);
11748
11749     return decl;
11750   }
11751 }
11752 \f
11753 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11754    An empty exprlist is a parmlist.  An exprlist which
11755    contains only identifiers at the global level
11756    is a parmlist.  Otherwise, it is an exprlist.  */
11757
11758 int
11759 parmlist_is_exprlist (exprs)
11760      tree exprs;
11761 {
11762   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11763     return 0;
11764
11765   if (toplevel_bindings_p ())
11766     {
11767       /* At the global level, if these are all identifiers,
11768          then it is a parmlist.  */
11769       while (exprs)
11770         {
11771           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11772             return 1;
11773           exprs = TREE_CHAIN (exprs);
11774         }
11775       return 0;
11776     }
11777   return 1;
11778 }
11779
11780 /* Subroutine of start_function.  Ensure that each of the parameter
11781    types (as listed in PARMS) is complete, as is required for a
11782    function definition.  */
11783
11784 static void
11785 require_complete_types_for_parms (parms)
11786      tree parms;
11787 {
11788   for (; parms; parms = TREE_CHAIN (parms))
11789     {
11790       tree type = TREE_TYPE (parms);
11791
11792       /* Try to complete the TYPE.  */
11793       type = complete_type (type);
11794
11795       if (type == error_mark_node)
11796         continue;
11797
11798       if (!COMPLETE_TYPE_P (type))
11799         {
11800           if (DECL_NAME (parms))
11801             error ("parameter `%s' has incomplete type",
11802                    IDENTIFIER_POINTER (DECL_NAME (parms)));
11803           else
11804             error ("parameter has incomplete type");
11805           TREE_TYPE (parms) = error_mark_node;
11806         }
11807       else
11808         layout_decl (parms, 0);
11809     }
11810 }
11811
11812 /* Returns non-zero if T is a local variable.  */
11813
11814 int
11815 local_variable_p (t)
11816      tree t;
11817 {
11818   if ((TREE_CODE (t) == VAR_DECL
11819        /* A VAR_DECL with a context that is a _TYPE is a static data
11820           member.  */
11821        && !TYPE_P (CP_DECL_CONTEXT (t))
11822        /* Any other non-local variable must be at namespace scope.  */
11823        && !DECL_NAMESPACE_SCOPE_P (t))
11824       || (TREE_CODE (t) == PARM_DECL))
11825     return 1;
11826
11827   return 0;
11828 }
11829
11830 /* Returns non-zero if T is an automatic local variable or a label.
11831    (These are the declarations that need to be remapped when the code
11832    containing them is duplicated.)  */
11833
11834 int
11835 nonstatic_local_decl_p (t)
11836      tree t;
11837 {
11838   return ((local_variable_p (t) && !TREE_STATIC (t))
11839           || TREE_CODE (t) == LABEL_DECL
11840           || TREE_CODE (t) == RESULT_DECL);
11841 }
11842
11843 /* Like local_variable_p, but suitable for use as a tree-walking
11844    function.  */
11845
11846 static tree
11847 local_variable_p_walkfn (tp, walk_subtrees, data)
11848      tree *tp;
11849      int *walk_subtrees ATTRIBUTE_UNUSED;
11850      void *data ATTRIBUTE_UNUSED;
11851 {
11852   return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
11853           ? *tp : NULL_TREE);
11854 }
11855
11856 /* Check that ARG, which is a default-argument expression for a
11857    parameter DECL, is legal.  Returns ARG, or ERROR_MARK_NODE, if
11858    something goes wrong.  DECL may also be a _TYPE node, rather than a
11859    DECL, if there is no DECL available.  */
11860
11861 tree
11862 check_default_argument (decl, arg)
11863      tree decl;
11864      tree arg;
11865 {
11866   tree var;
11867   tree decl_type;
11868
11869   if (TREE_CODE (arg) == DEFAULT_ARG)
11870     /* We get a DEFAULT_ARG when looking at an in-class declaration
11871        with a default argument.  Ignore the argument for now; we'll
11872        deal with it after the class is complete.  */
11873     return arg;
11874
11875   if (processing_template_decl || uses_template_parms (arg))
11876     /* We don't do anything checking until instantiation-time.  Note
11877        that there may be uninstantiated arguments even for an
11878        instantiated function, since default arguments are not
11879        instantiated until they are needed.  */
11880     return arg;
11881
11882   if (TYPE_P (decl))
11883     {
11884       decl_type = decl;
11885       decl = NULL_TREE;
11886     }
11887   else
11888     decl_type = TREE_TYPE (decl);
11889
11890   if (arg == error_mark_node
11891       || decl == error_mark_node
11892       || TREE_TYPE (arg) == error_mark_node
11893       || decl_type == error_mark_node)
11894     /* Something already went wrong.  There's no need to check
11895        further.  */
11896     return error_mark_node;
11897
11898   /* [dcl.fct.default]
11899
11900      A default argument expression is implicitly converted to the
11901      parameter type.  */
11902   if (!TREE_TYPE (arg)
11903       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
11904     {
11905       if (decl)
11906         cp_error ("default argument for `%#D' has type `%T'",
11907                   decl, TREE_TYPE (arg));
11908       else
11909         cp_error ("default argument for parameter of type `%T' has type `%T'",
11910                   decl_type, TREE_TYPE (arg));
11911
11912       return error_mark_node;
11913     }
11914
11915   /* [dcl.fct.default]
11916
11917      Local variables shall not be used in default argument
11918      expressions.
11919
11920      The keyword `this' shall not be used in a default argument of a
11921      member function.  */
11922   var = walk_tree (&arg, local_variable_p_walkfn, NULL);
11923   if (var)
11924     {
11925       cp_error ("default argument `%E' uses local variable `%D'",
11926                 arg, var);
11927       return error_mark_node;
11928     }
11929
11930   /* All is well.  */
11931   return arg;
11932 }
11933
11934 /* Decode the list of parameter types for a function type.
11935    Given the list of things declared inside the parens,
11936    return a list of types.
11937
11938    The list we receive can have three kinds of elements:
11939    an IDENTIFIER_NODE for names given without types,
11940    a TREE_LIST node for arguments given as typespecs or names with typespecs,
11941    or void_type_node, to mark the end of an argument list
11942    when additional arguments are not permitted (... was not used).
11943
11944    FUNCDEF_FLAG is nonzero for a function definition, 0 for
11945    a mere declaration.  A nonempty identifier-list gets an error message
11946    when FUNCDEF_FLAG is zero.
11947    If FUNCDEF_FLAG is 1, then parameter types must be complete.
11948    If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
11949
11950    If all elements of the input list contain types,
11951    we return a list of the types.
11952    If all elements contain no type (except perhaps a void_type_node
11953    at the end), we return a null list.
11954    If some have types and some do not, it is an error, and we
11955    return a null list.
11956
11957    Also set last_function_parms to either
11958    a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
11959    A list of names is converted to a chain of PARM_DECLs
11960    by store_parm_decls so that ultimately it is always a chain of decls.
11961
11962    Note that in C++, parameters can take default values.  These default
11963    values are in the TREE_PURPOSE field of the TREE_LIST.  It is
11964    an error to specify default values which are followed by parameters
11965    that have no default values, or an ELLIPSES.  For simplicities sake,
11966    only parameters which are specified with their types can take on
11967    default values.  */
11968
11969 static tree
11970 grokparms (first_parm, funcdef_flag)
11971      tree first_parm;
11972      int funcdef_flag;
11973 {
11974   tree result = NULL_TREE;
11975   tree decls = NULL_TREE;
11976
11977   if (first_parm != NULL_TREE
11978       && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
11979     {
11980       if (! funcdef_flag)
11981         pedwarn ("parameter names (without types) in function declaration");
11982       last_function_parms = first_parm;
11983       return NULL_TREE;
11984     }
11985   else if (first_parm != NULL_TREE
11986            && TREE_CODE (TREE_VALUE (first_parm)) != TREE_LIST
11987            && TREE_CODE (TREE_VALUE (first_parm)) != VOID_TYPE)
11988     my_friendly_abort (145);
11989   else
11990     {
11991       /* Types were specified.  This is a list of declarators
11992          each represented as a TREE_LIST node.  */
11993       register tree parm, chain;
11994       int any_init = 0, any_error = 0;
11995
11996       if (first_parm != NULL_TREE)
11997         {
11998           tree last_result = NULL_TREE;
11999           tree last_decl = NULL_TREE;
12000
12001           for (parm = first_parm; parm != NULL_TREE; parm = chain)
12002             {
12003               tree type = NULL_TREE, list_node = parm;
12004               register tree decl = TREE_VALUE (parm);
12005               tree init = TREE_PURPOSE (parm);
12006
12007               chain = TREE_CHAIN (parm);
12008               /* @@ weak defense against parse errors.  */
12009               if (TREE_CODE (decl) != VOID_TYPE
12010                   && TREE_CODE (decl) != TREE_LIST)
12011                 {
12012                   /* Give various messages as the need arises.  */
12013                   if (TREE_CODE (decl) == STRING_CST)
12014                     cp_error ("invalid string constant `%E'", decl);
12015                   else if (TREE_CODE (decl) == INTEGER_CST)
12016                     error ("invalid integer constant in parameter list, did you forget to give parameter name?");
12017                   continue;
12018                 }
12019
12020               if (TREE_CODE (decl) != VOID_TYPE)
12021                 {
12022                   decl = grokdeclarator (TREE_VALUE (decl),
12023                                          TREE_PURPOSE (decl),
12024                                          PARM, init != NULL_TREE,
12025                                          NULL_TREE);
12026                   if (! decl || TREE_TYPE (decl) == error_mark_node)
12027                     continue;
12028
12029                   /* Top-level qualifiers on the parameters are
12030                      ignored for function types.  */
12031                   type = TYPE_MAIN_VARIANT (TREE_TYPE (decl));
12032
12033                   if (TREE_CODE (type) == VOID_TYPE)
12034                     decl = void_type_node;
12035                   else if (TREE_CODE (type) == METHOD_TYPE)
12036                     {
12037                       if (DECL_NAME (decl))
12038                         /* Cannot use the decl here because
12039                            we don't have DECL_CONTEXT set up yet.  */
12040                         cp_error ("parameter `%D' invalidly declared method type",
12041                                   DECL_NAME (decl));
12042                       else
12043                         error ("parameter invalidly declared method type");
12044                       type = build_pointer_type (type);
12045                       TREE_TYPE (decl) = type;
12046                     }
12047                   else if (TREE_CODE (type) == OFFSET_TYPE)
12048                     {
12049                       if (DECL_NAME (decl))
12050                         cp_error ("parameter `%D' invalidly declared offset type",
12051                                   DECL_NAME (decl));
12052                       else
12053                         error ("parameter invalidly declared offset type");
12054                       type = build_pointer_type (type);
12055                       TREE_TYPE (decl) = type;
12056                     }
12057                   else if (abstract_virtuals_error (decl, type))
12058                     any_error = 1;  /* Seems like a good idea. */
12059                   else if (POINTER_TYPE_P (type))
12060                     {
12061                       tree t = type;
12062                       while (POINTER_TYPE_P (t)
12063                              || (TREE_CODE (t) == ARRAY_TYPE
12064                                  && TYPE_DOMAIN (t) != NULL_TREE))
12065                         t = TREE_TYPE (t);
12066                       if (TREE_CODE (t) == ARRAY_TYPE)
12067                         cp_error ("parameter type `%T' includes %s to array of unknown bound",
12068                                   type,
12069                                   TYPE_PTR_P (type) ? "pointer" : "reference");
12070                     }
12071                 }
12072
12073               if (TREE_CODE (decl) == VOID_TYPE)
12074                 {
12075                   if (result == NULL_TREE)
12076                     {
12077                       result = void_list_node;
12078                       last_result = result;
12079                     }
12080                   else
12081                     {
12082                       TREE_CHAIN (last_result) = void_list_node;
12083                       last_result = void_list_node;
12084                     }
12085                   if (chain
12086                       && (chain != void_list_node || TREE_CHAIN (chain)))
12087                     error ("`void' in parameter list must be entire list");
12088                   break;
12089                 }
12090
12091               /* Since there is a prototype, args are passed in their own types.  */
12092               DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
12093               if (PROMOTE_PROTOTYPES
12094                   && (TREE_CODE (type) == INTEGER_TYPE
12095                       || TREE_CODE (type) == ENUMERAL_TYPE)
12096                   && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
12097                 DECL_ARG_TYPE (decl) = integer_type_node;
12098               if (!any_error && init)
12099                 {
12100                   any_init++;
12101                   init = check_default_argument (decl, init);
12102                 }
12103               else
12104                 init = NULL_TREE;
12105
12106               if (decls == NULL_TREE)
12107                 {
12108                   decls = decl;
12109                   last_decl = decls;
12110                 }
12111               else
12112                 {
12113                   TREE_CHAIN (last_decl) = decl;
12114                   last_decl = decl;
12115                 }
12116               list_node = tree_cons (init, type, NULL_TREE);
12117               if (result == NULL_TREE)
12118                 {
12119                   result = list_node;
12120                   last_result = result;
12121                 }
12122               else
12123                 {
12124                   TREE_CHAIN (last_result) = list_node;
12125                   last_result = list_node;
12126                 }
12127             }
12128           if (last_result)
12129             TREE_CHAIN (last_result) = NULL_TREE;
12130           /* If there are no parameters, and the function does not end
12131              with `...', then last_decl will be NULL_TREE.  */
12132           if (last_decl != NULL_TREE)
12133             TREE_CHAIN (last_decl) = NULL_TREE;
12134         }
12135     }
12136
12137   last_function_parms = decls;
12138
12139   return result;
12140 }
12141
12142 /* Called from the parser to update an element of TYPE_ARG_TYPES for some
12143    FUNCTION_TYPE with the newly parsed version of its default argument, which
12144    was previously digested as text.  See snarf_defarg et al in lex.c.  */
12145
12146 void
12147 replace_defarg (arg, init)
12148      tree arg, init;
12149 {
12150   if (! processing_template_decl
12151       && ! can_convert_arg (TREE_VALUE (arg), TREE_TYPE (init), init))
12152     cp_pedwarn ("invalid type `%T' for default argument to `%T'",
12153                 TREE_TYPE (init), TREE_VALUE (arg));
12154   TREE_PURPOSE (arg) = init;
12155 }
12156 \f
12157 /* D is a constructor or overloaded `operator='.  Returns non-zero if
12158    D's arguments allow it to be a copy constructor, or copy assignment
12159    operator.  */
12160
12161 int
12162 copy_args_p (d)
12163      tree d;
12164 {
12165   tree t;
12166
12167   if (!DECL_FUNCTION_MEMBER_P (d))
12168     return 0;
12169
12170   t = FUNCTION_ARG_CHAIN (d);
12171   if (DECL_CONSTRUCTOR_P (d) && DECL_HAS_IN_CHARGE_PARM_P (d))
12172     t = TREE_CHAIN (t);
12173   if (t && TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
12174       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t)))
12175           == DECL_CONTEXT (d))
12176       && (TREE_CHAIN (t) == NULL_TREE
12177           || TREE_CHAIN (t) == void_list_node
12178           || TREE_PURPOSE (TREE_CHAIN (t))))
12179     return 1;
12180   return 0;
12181 }
12182
12183 /* These memoizing functions keep track of special properties which
12184    a class may have.  `grok_ctor_properties' notices whether a class
12185    has a constructor of the form X(X&), and also complains
12186    if the class has a constructor of the form X(X).
12187    `grok_op_properties' takes notice of the various forms of
12188    operator= which are defined, as well as what sorts of type conversion
12189    may apply.  Both functions take a FUNCTION_DECL as an argument.  */
12190
12191 int
12192 grok_ctor_properties (ctype, decl)
12193      tree ctype, decl;
12194 {
12195   tree parmtypes = FUNCTION_ARG_CHAIN (decl);
12196   tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
12197
12198   /* When a type has virtual baseclasses, a magical first int argument is
12199      added to any ctor so we can tell if the class has been initialized
12200      yet.  This could screw things up in this function, so we deliberately
12201      ignore the leading int if we're in that situation.  */
12202   if (DECL_HAS_IN_CHARGE_PARM_P (decl))
12203     {
12204       my_friendly_assert (parmtypes
12205                           && TREE_VALUE (parmtypes) == integer_type_node,
12206                           980529);
12207       parmtypes = TREE_CHAIN (parmtypes);
12208       parmtype = TREE_VALUE (parmtypes);
12209     }
12210
12211   /* [class.copy]
12212
12213      A non-template constructor for class X is a copy constructor if
12214      its first parameter is of type X&, const X&, volatile X& or const
12215      volatile X&, and either there are no other parameters or else all
12216      other parameters have default arguments.  */
12217   if (TREE_CODE (parmtype) == REFERENCE_TYPE
12218       && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype
12219       && (TREE_CHAIN (parmtypes) == NULL_TREE
12220           || TREE_CHAIN (parmtypes) == void_list_node
12221           || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
12222       && !(DECL_TEMPLATE_INSTANTIATION (decl)
12223            && is_member_template (DECL_TI_TEMPLATE (decl))))
12224     {
12225       TYPE_HAS_INIT_REF (ctype) = 1;
12226       if (CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12227         TYPE_HAS_CONST_INIT_REF (ctype) = 1;
12228     }
12229   /* [class.copy]
12230
12231      A declaration of a constructor for a class X is ill-formed if its
12232      first parameter is of type (optionally cv-qualified) X and either
12233      there are no other parameters or else all other parameters have
12234      default arguments.
12235
12236      We *don't* complain about member template instantiations that
12237      have this form, though; they can occur as we try to decide what
12238      constructor to use during overload resolution.  Since overload
12239      resolution will never prefer such a constructor to the
12240      non-template copy constructor (which is either explicitly or
12241      implicitly defined), there's no need to worry about their
12242      existence.  Theoretically, they should never even be
12243      instantiated, but that's hard to forestall.  */
12244   else if (TYPE_MAIN_VARIANT (parmtype) == ctype
12245            && (TREE_CHAIN (parmtypes) == NULL_TREE
12246                || TREE_CHAIN (parmtypes) == void_list_node
12247                || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
12248            && !(DECL_TEMPLATE_INSTANTIATION (decl)
12249                 && is_member_template (DECL_TI_TEMPLATE (decl))))
12250     {
12251       cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
12252                 ctype, ctype);
12253       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
12254       return 0;
12255     }
12256   else if (TREE_CODE (parmtype) == VOID_TYPE
12257            || TREE_PURPOSE (parmtypes) != NULL_TREE)
12258     TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
12259
12260   return 1;
12261 }
12262
12263 /* An operator with this code is unary, but can also be binary.  */
12264
12265 static int
12266 ambi_op_p (code)
12267      enum tree_code code;
12268 {
12269   return (code == INDIRECT_REF
12270           || code == ADDR_EXPR
12271           || code == CONVERT_EXPR
12272           || code == NEGATE_EXPR
12273           || code == PREINCREMENT_EXPR
12274           || code == PREDECREMENT_EXPR);
12275 }
12276
12277 /* An operator with this name can only be unary.  */
12278
12279 static int
12280 unary_op_p (code)
12281      enum tree_code code;
12282 {
12283   return (code == TRUTH_NOT_EXPR
12284           || code == BIT_NOT_EXPR
12285           || code == COMPONENT_REF
12286           || code == TYPE_EXPR);
12287 }
12288
12289 /* Do a little sanity-checking on how they declared their operator.  */
12290
12291 void
12292 grok_op_properties (decl, virtualp, friendp)
12293      tree decl;
12294      int virtualp, friendp;
12295 {
12296   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
12297   tree argtype;
12298   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
12299   tree name = DECL_NAME (decl);
12300   enum tree_code operator_code;
12301   int arity;
12302
12303   /* Count the number of arguments.  */
12304   for (argtype = argtypes, arity = 0;
12305        argtype && argtype != void_list_node;
12306        argtype = TREE_CHAIN (argtype))
12307     ++arity;
12308
12309   if (current_class_type == NULL_TREE)
12310     friendp = 1;
12311
12312   if (DECL_CONV_FN_P (decl))
12313     operator_code = TYPE_EXPR;
12314   else
12315     do
12316       {
12317 #define DEF_OPERATOR(NAME, CODE, NEW_MANGLING, OLD_MANGING, ARITY, ASSN_P)  \
12318         if (ansi_opname (CODE) == name)                                     \
12319           {                                                                 \
12320             operator_code = CODE;                                           \
12321             break;                                                          \
12322           }                                                                 \
12323         else if (ansi_assopname (CODE) == name)                             \
12324           {                                                                 \
12325             operator_code = CODE;                                           \
12326             DECL_ASSIGNMENT_OPERATOR_P (decl) = 1;                          \
12327             break;                                                          \
12328           }
12329
12330 #include "operators.def"
12331 #undef DEF_OPERATOR
12332
12333         my_friendly_abort (20000527);
12334       }
12335     while (0);
12336   my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526);
12337   SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12338
12339   if (! friendp)
12340     {
12341       switch (operator_code)
12342         {
12343         case CALL_EXPR:
12344           TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
12345           break;
12346
12347         case ARRAY_REF:
12348           TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
12349           break;
12350
12351         case COMPONENT_REF:
12352         case MEMBER_REF:
12353           TYPE_OVERLOADS_ARROW (current_class_type) = 1;
12354           break;
12355
12356         case NEW_EXPR:
12357           TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
12358           break;
12359
12360         case DELETE_EXPR:
12361           TYPE_GETS_DELETE (current_class_type) |= 1;
12362           break;
12363
12364         case VEC_NEW_EXPR:
12365           TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
12366           break;
12367
12368         case VEC_DELETE_EXPR:
12369           TYPE_GETS_DELETE (current_class_type) |= 2;
12370           break;
12371
12372         default:
12373           break;
12374         }
12375     }
12376
12377   if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
12378     {
12379       /* When the compiler encounters the definition of A::operator new, it
12380          doesn't look at the class declaration to find out if it's static.  */
12381       if (methodp)
12382         revert_static_member_fn (decl);
12383
12384       /* Take care of function decl if we had syntax errors.  */
12385       if (argtypes == NULL_TREE)
12386         TREE_TYPE (decl)
12387           = build_function_type (ptr_type_node,
12388                                  hash_tree_chain (integer_type_node,
12389                                                   void_list_node));
12390       else
12391         TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12392     }
12393   else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
12394     {
12395       if (methodp)
12396         revert_static_member_fn (decl);
12397
12398       if (argtypes == NULL_TREE)
12399         TREE_TYPE (decl)
12400           = build_function_type (void_type_node,
12401                                  hash_tree_chain (ptr_type_node,
12402                                                   void_list_node));
12403       else
12404         TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12405     }
12406   else
12407     {
12408       /* An operator function must either be a non-static member function
12409          or have at least one parameter of a class, a reference to a class,
12410          an enumeration, or a reference to an enumeration.  13.4.0.6 */
12411       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12412         {
12413           if (operator_code == TYPE_EXPR
12414               || operator_code == CALL_EXPR
12415               || operator_code == COMPONENT_REF
12416               || operator_code == ARRAY_REF
12417               || operator_code == NOP_EXPR)
12418             cp_error ("`%D' must be a nonstatic member function", decl);
12419           else
12420             {
12421               tree p = argtypes;
12422
12423               if (DECL_STATIC_FUNCTION_P (decl))
12424                 cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
12425
12426               if (p)
12427                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12428                   {
12429                     tree arg = TREE_VALUE (p);
12430                     if (TREE_CODE (arg) == REFERENCE_TYPE)
12431                       arg = TREE_TYPE (arg);
12432
12433                     /* This lets bad template code slip through.  */
12434                     if (IS_AGGR_TYPE (arg)
12435                         || TREE_CODE (arg) == ENUMERAL_TYPE
12436                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12437                         || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
12438                       goto foundaggr;
12439                   }
12440               cp_error
12441                 ("`%D' must have an argument of class or enumerated type",
12442                  decl);
12443             foundaggr:
12444               ;
12445             }
12446         }
12447
12448       if (operator_code == CALL_EXPR)
12449         return;                 /* No restrictions on args. */
12450
12451       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12452         {
12453           tree t = TREE_TYPE (name);
12454           if (! friendp)
12455             {
12456               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12457               const char *what = 0;
12458
12459               if (ref)
12460                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12461
12462               if (TREE_CODE (t) == VOID_TYPE)
12463                 what = "void";
12464               else if (t == current_class_type)
12465                 what = "the same type";
12466               /* Don't force t to be complete here.  */
12467               else if (IS_AGGR_TYPE (t)
12468                        && COMPLETE_TYPE_P (t)
12469                        && DERIVED_FROM_P (t, current_class_type))
12470                 what = "a base class";
12471
12472               if (what)
12473                 warning ("conversion to %s%s will never use a type conversion operator",
12474                          ref ? "a reference to " : "", what);
12475             }
12476         }
12477
12478       if (DECL_ASSIGNMENT_OPERATOR_P (decl)
12479           && operator_code == NOP_EXPR)
12480         {
12481           tree parmtype;
12482
12483           if (arity != 2 && methodp)
12484             {
12485               cp_error ("`%D' must take exactly one argument", decl);
12486               return;
12487             }
12488           parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
12489
12490           /* [class.copy]
12491
12492              A user-declared copy assignment operator X::operator= is
12493              a non-static non-template member function of class X with
12494              exactly one parameter of type X, X&, const X&, volatile
12495              X& or const volatile X&.  */
12496           if (copy_assignment_arg_p (parmtype, virtualp)
12497               && !(DECL_TEMPLATE_INSTANTIATION (decl)
12498                    && is_member_template (DECL_TI_TEMPLATE (decl)))
12499               && ! friendp)
12500             {
12501               TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
12502               if (TREE_CODE (parmtype) != REFERENCE_TYPE
12503                   || CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12504                 TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
12505             }
12506         }
12507       else if (operator_code == COND_EXPR)
12508         {
12509           /* 13.4.0.3 */
12510           cp_error ("ISO C++ prohibits overloading operator ?:");
12511         }
12512       else if (ambi_op_p (operator_code))
12513         {
12514           if (arity == 1)
12515             /* We pick the one-argument operator codes by default, so
12516                we don't have to change anything.  */
12517             ;
12518           else if (arity == 2)
12519             {
12520               /* If we thought this was a unary operator, we now know
12521                  it to be a binary operator.  */
12522               switch (operator_code)
12523                 {
12524                 case INDIRECT_REF:
12525                   operator_code = MULT_EXPR;
12526                   break;
12527
12528                 case ADDR_EXPR:
12529                   operator_code = BIT_AND_EXPR;
12530                   break;
12531
12532                 case CONVERT_EXPR:
12533                   operator_code = PLUS_EXPR;
12534                   break;
12535
12536                 case NEGATE_EXPR:
12537                   operator_code = MINUS_EXPR;
12538                   break;
12539
12540                 case PREINCREMENT_EXPR:
12541                   operator_code = POSTINCREMENT_EXPR;
12542                   break;
12543
12544                 case PREDECREMENT_EXPR:
12545                   operator_code = POSTDECREMENT_EXPR;
12546                   break;
12547
12548                 default:
12549                   my_friendly_abort (20000527);
12550                 }
12551
12552               SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12553
12554               if ((operator_code == POSTINCREMENT_EXPR
12555                    || operator_code == POSTDECREMENT_EXPR)
12556                   && ! processing_template_decl
12557                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12558                 {
12559                   if (methodp)
12560                     cp_error ("postfix `%D' must take `int' as its argument",
12561                               decl);
12562                   else
12563                     cp_error
12564                       ("postfix `%D' must take `int' as its second argument",
12565                        decl);
12566                 }
12567             }
12568           else
12569             {
12570               if (methodp)
12571                 cp_error ("`%D' must take either zero or one argument", decl);
12572               else
12573                 cp_error ("`%D' must take either one or two arguments", decl);
12574             }
12575
12576           /* More Effective C++ rule 6.  */
12577           if (warn_ecpp
12578               && (operator_code == POSTINCREMENT_EXPR
12579                   || operator_code == POSTDECREMENT_EXPR
12580                   || operator_code == PREINCREMENT_EXPR
12581                   || operator_code == PREDECREMENT_EXPR))
12582             {
12583               tree arg = TREE_VALUE (argtypes);
12584               tree ret = TREE_TYPE (TREE_TYPE (decl));
12585               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12586                 arg = TREE_TYPE (arg);
12587               arg = TYPE_MAIN_VARIANT (arg);
12588               if (operator_code == PREINCREMENT_EXPR
12589                   || operator_code == PREDECREMENT_EXPR)
12590                 {
12591                   if (TREE_CODE (ret) != REFERENCE_TYPE
12592                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12593                                        arg))
12594                     cp_warning ("prefix `%D' should return `%T'", decl,
12595                                 build_reference_type (arg));
12596                 }
12597               else
12598                 {
12599                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12600                     cp_warning ("postfix `%D' should return `%T'", decl, arg);
12601                 }
12602             }
12603         }
12604       else if (unary_op_p (operator_code))
12605         {
12606           if (arity != 1)
12607             {
12608               if (methodp)
12609                 cp_error ("`%D' must take `void'", decl);
12610               else
12611                 cp_error ("`%D' must take exactly one argument", decl);
12612             }
12613         }
12614       else /* if (binary_op_p (operator_code)) */
12615         {
12616           if (arity != 2)
12617             {
12618               if (methodp)
12619                 cp_error ("`%D' must take exactly one argument", decl);
12620               else
12621                 cp_error ("`%D' must take exactly two arguments", decl);
12622             }
12623
12624           /* More Effective C++ rule 7.  */
12625           if (warn_ecpp
12626               && (operator_code == TRUTH_ANDIF_EXPR
12627                   || operator_code == TRUTH_ORIF_EXPR
12628                   || operator_code == COMPOUND_EXPR))
12629             cp_warning ("user-defined `%D' always evaluates both arguments",
12630                         decl);
12631         }
12632
12633       /* Effective C++ rule 23.  */
12634       if (warn_ecpp
12635           && arity == 2
12636           && (operator_code == PLUS_EXPR
12637               || operator_code == MINUS_EXPR
12638               || operator_code == TRUNC_DIV_EXPR
12639               || operator_code == MULT_EXPR)
12640           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12641         cp_warning ("`%D' should return by value", decl);
12642
12643       /* 13.4.0.8 */
12644       for (; argtypes && argtypes != void_list_node;
12645           argtypes = TREE_CHAIN (argtypes))
12646         if (TREE_PURPOSE (argtypes))
12647           {
12648             TREE_PURPOSE (argtypes) = NULL_TREE;
12649             if (operator_code == POSTINCREMENT_EXPR
12650                 || operator_code == POSTDECREMENT_EXPR)
12651               {
12652                 if (pedantic)
12653                   cp_pedwarn ("`%D' cannot have default arguments", decl);
12654               }
12655             else
12656               cp_error ("`%D' cannot have default arguments", decl);
12657           }
12658
12659     }
12660 }
12661 \f
12662 static const char *
12663 tag_name (code)
12664      enum tag_types code;
12665 {
12666   switch (code)
12667     {
12668     case record_type:
12669       return "struct";
12670     case class_type:
12671       return "class";
12672     case union_type:
12673       return "union ";
12674     case enum_type:
12675       return "enum";
12676     default:
12677       my_friendly_abort (981122);
12678     }
12679 }
12680
12681 /* Get the struct, enum or union (CODE says which) with tag NAME.
12682    Define the tag as a forward-reference if it is not defined.
12683
12684    C++: If a class derivation is given, process it here, and report
12685    an error if multiple derivation declarations are not identical.
12686
12687    If this is a definition, come in through xref_tag and only look in
12688    the current frame for the name (since C++ allows new names in any
12689    scope.)  */
12690
12691 tree
12692 xref_tag (code_type_node, name, globalize)
12693      tree code_type_node;
12694      tree name;
12695      int globalize;
12696 {
12697   enum tag_types tag_code;
12698   enum tree_code code;
12699   register tree ref, t;
12700   struct binding_level *b = current_binding_level;
12701   int got_type = 0;
12702   tree attributes = NULL_TREE;
12703   tree context = NULL_TREE;
12704
12705   /* If we are called from the parser, code_type_node will sometimes be a
12706      TREE_LIST.  This indicates that the user wrote
12707      "class __attribute__ ((foo)) bar".  Extract the attributes so we can
12708      use them later.  */
12709   if (TREE_CODE (code_type_node) == TREE_LIST)
12710     {
12711       attributes = TREE_PURPOSE (code_type_node);
12712       code_type_node = TREE_VALUE (code_type_node);
12713     }
12714
12715   tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12716   switch (tag_code)
12717     {
12718     case record_type:
12719     case class_type:
12720       code = RECORD_TYPE;
12721       break;
12722     case union_type:
12723       code = UNION_TYPE;
12724       break;
12725     case enum_type:
12726       code = ENUMERAL_TYPE;
12727       break;
12728     default:
12729       my_friendly_abort (18);
12730     }
12731
12732   /* If a cross reference is requested, look up the type
12733      already defined for this tag and return it.  */
12734   if (TYPE_P (name))
12735     {
12736       t = name;
12737       name = TYPE_IDENTIFIER (t);
12738       got_type = 1;
12739     }
12740   else
12741     t = IDENTIFIER_TYPE_VALUE (name);
12742
12743   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12744       && TREE_CODE (t) != TEMPLATE_TEMPLATE_PARM)
12745     t = NULL_TREE;
12746
12747   if (! globalize)
12748     {
12749       /* If we know we are defining this tag, only look it up in
12750          this scope and don't try to find it as a type.  */
12751       ref = lookup_tag (code, name, b, 1);
12752     }
12753   else
12754     {
12755       if (t)
12756         {
12757           /* [dcl.type.elab] If the identifier resolves to a
12758              typedef-name or a template type-parameter, the
12759              elaborated-type-specifier is ill-formed.  */
12760           if (t != TYPE_MAIN_VARIANT (t)
12761               || (CLASS_TYPE_P (t) && TYPE_WAS_ANONYMOUS (t)))
12762             cp_pedwarn ("using typedef-name `%D' after `%s'",
12763                         TYPE_NAME (t), tag_name (tag_code));
12764           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12765             cp_error ("using template type parameter `%T' after `%s'",
12766                       t, tag_name (tag_code));
12767
12768           ref = t;
12769         }
12770       else
12771         ref = lookup_tag (code, name, b, 0);
12772
12773       if (! ref)
12774         {
12775           /* Try finding it as a type declaration.  If that wins,
12776              use it.  */
12777           ref = lookup_name (name, 1);
12778
12779           if (ref != NULL_TREE
12780               && processing_template_decl
12781               && DECL_CLASS_TEMPLATE_P (ref)
12782               && template_class_depth (current_class_type) == 0)
12783             /* Since GLOBALIZE is true, we're declaring a global
12784                template, so we want this type.  */
12785             ref = DECL_TEMPLATE_RESULT (ref);
12786
12787           if (ref && TREE_CODE (ref) == TYPE_DECL
12788               && TREE_CODE (TREE_TYPE (ref)) == code)
12789             ref = TREE_TYPE (ref);
12790           else
12791             ref = NULL_TREE;
12792         }
12793
12794       if (ref && current_class_type
12795           && template_class_depth (current_class_type)
12796           && PROCESSING_REAL_TEMPLATE_DECL_P ())
12797         {
12798           /* Since GLOBALIZE is non-zero, we are not looking at a
12799              definition of this tag.  Since, in addition, we are currently
12800              processing a (member) template declaration of a template
12801              class, we must be very careful; consider:
12802
12803                template <class X>
12804                struct S1
12805
12806                template <class U>
12807                struct S2
12808                { template <class V>
12809                friend struct S1; };
12810
12811              Here, the S2::S1 declaration should not be confused with the
12812              outer declaration.  In particular, the inner version should
12813              have a template parameter of level 2, not level 1.  This
12814              would be particularly important if the member declaration
12815              were instead:
12816
12817                template <class V = U> friend struct S1;
12818
12819              say, when we should tsubst into `U' when instantiating
12820              S2.  On the other hand, when presented with:
12821
12822                  template <class T>
12823                  struct S1 {
12824                    template <class U>
12825                    struct S2 {};
12826                    template <class U>
12827                    friend struct S2;
12828                  };
12829
12830               we must find the inner binding eventually.  We
12831               accomplish this by making sure that the new type we
12832               create to represent this declaration has the right
12833               TYPE_CONTEXT.  */
12834           context = TYPE_CONTEXT (ref);
12835           ref = NULL_TREE;
12836         }
12837     }
12838
12839   if (! ref)
12840     {
12841       /* If no such tag is yet defined, create a forward-reference node
12842          and record it as the "definition".
12843          When a real declaration of this type is found,
12844          the forward-reference will be altered into a real type.  */
12845       if (code == ENUMERAL_TYPE)
12846         {
12847           cp_error ("use of enum `%#D' without previous declaration", name);
12848
12849           ref = make_node (ENUMERAL_TYPE);
12850
12851           /* Give the type a default layout like unsigned int
12852              to avoid crashing if it does not get defined.  */
12853           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12854           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12855           TYPE_USER_ALIGN (ref) = 0;
12856           TREE_UNSIGNED (ref) = 1;
12857           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12858           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12859           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12860
12861           /* Enable us to recognize when a type is created in class context.
12862              To do nested classes correctly, this should probably be cleared
12863              out when we leave this classes scope.  Currently this in only
12864              done in `start_enum'.  */
12865
12866           pushtag (name, ref, globalize);
12867         }
12868       else
12869         {
12870           struct binding_level *old_b = class_binding_level;
12871
12872           ref = make_aggr_type (code);
12873           TYPE_CONTEXT (ref) = context;
12874
12875 #ifdef NONNESTED_CLASSES
12876           /* Class types don't nest the way enums do.  */
12877           class_binding_level = (struct binding_level *)0;
12878 #endif
12879           pushtag (name, ref, globalize);
12880           class_binding_level = old_b;
12881         }
12882     }
12883   else
12884     {
12885       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12886         redeclare_class_template (ref, current_template_parms);
12887     }
12888
12889   /* Until the type is defined, tentatively accept whatever
12890      structure tag the user hands us.  */
12891   if (!COMPLETE_TYPE_P (ref)
12892       && ref != current_class_type
12893       /* Have to check this, in case we have contradictory tag info.  */
12894       && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
12895     {
12896       if (tag_code == class_type)
12897         CLASSTYPE_DECLARED_CLASS (ref) = 1;
12898       else if (tag_code == record_type)
12899         CLASSTYPE_DECLARED_CLASS (ref) = 0;
12900     }
12901
12902   TREE_TYPE (ref) = attributes;
12903
12904   return ref;
12905 }
12906
12907 tree
12908 xref_tag_from_type (old, id, globalize)
12909      tree old, id;
12910      int globalize;
12911 {
12912   tree code_type_node;
12913
12914   if (TREE_CODE (old) == RECORD_TYPE)
12915     code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
12916                       ? class_type_node : record_type_node);
12917   else
12918     code_type_node = union_type_node;
12919
12920   if (id == NULL_TREE)
12921     id = TYPE_IDENTIFIER (old);
12922
12923   return xref_tag (code_type_node, id, globalize);
12924 }
12925
12926 /* REF is a type (named NAME), for which we have just seen some
12927    baseclasses.  BINFO is a list of those baseclasses; the
12928    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12929    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
12930    struct, or union.  */
12931
12932 void
12933 xref_basetypes (code_type_node, name, ref, binfo)
12934      tree code_type_node;
12935      tree name, ref;
12936      tree binfo;
12937 {
12938   /* In the declaration `A : X, Y, ... Z' we mark all the types
12939      (A, X, Y, ..., Z) so we can check for duplicates.  */
12940   tree binfos;
12941   tree base;
12942
12943   int i, len;
12944   enum tag_types tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12945
12946   if (tag_code == union_type)
12947     {
12948       cp_error ("derived union `%T' invalid", ref);
12949       return;
12950     }
12951
12952   len = list_length (binfo);
12953
12954   /* First, make sure that any templates in base-classes are
12955      instantiated.  This ensures that if we call ourselves recursively
12956      we do not get confused about which classes are marked and which
12957      are not.  */
12958   for (base = binfo; base; base = TREE_CHAIN (base))
12959     complete_type (TREE_VALUE (base));
12960
12961   SET_CLASSTYPE_MARKED (ref);
12962   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
12963
12964   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
12965     {
12966       /* The base of a derived struct is public by default.  */
12967       int via_public
12968         = (TREE_PURPOSE (binfo) == access_public_node
12969            || TREE_PURPOSE (binfo) == access_public_virtual_node
12970            || (tag_code != class_type
12971                && (TREE_PURPOSE (binfo) == access_default_node
12972                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
12973       int via_protected
12974         = (TREE_PURPOSE (binfo) == access_protected_node
12975            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
12976       int via_virtual
12977         = (TREE_PURPOSE (binfo) == access_private_virtual_node
12978            || TREE_PURPOSE (binfo) == access_protected_virtual_node
12979            || TREE_PURPOSE (binfo) == access_public_virtual_node
12980            || TREE_PURPOSE (binfo) == access_default_virtual_node);
12981       tree basetype = TREE_VALUE (binfo);
12982       tree base_binfo;
12983
12984       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
12985         basetype = TREE_TYPE (basetype);
12986       if (!basetype
12987           || (TREE_CODE (basetype) != RECORD_TYPE
12988               && TREE_CODE (basetype) != TYPENAME_TYPE
12989               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
12990               && TREE_CODE (basetype) != TEMPLATE_TEMPLATE_PARM))
12991         {
12992           cp_error ("base type `%T' fails to be a struct or class type",
12993                     TREE_VALUE (binfo));
12994           continue;
12995         }
12996
12997       GNU_xref_hier (name, basetype, via_public, via_virtual, 0);
12998
12999       /* This code replaces similar code in layout_basetypes.
13000          We put the complete_type first for implicit `typename'.  */
13001       if (!COMPLETE_TYPE_P (basetype)
13002           && ! (current_template_parms && uses_template_parms (basetype)))
13003         {
13004           cp_error ("base class `%T' has incomplete type", basetype);
13005           continue;
13006         }
13007       else
13008         {
13009           if (CLASSTYPE_MARKED (basetype))
13010             {
13011               if (basetype == ref)
13012                 cp_error ("recursive type `%T' undefined", basetype);
13013               else
13014                 cp_error ("duplicate base type `%T' invalid", basetype);
13015               continue;
13016             }
13017
13018           if (TYPE_FOR_JAVA (basetype)
13019               && (current_lang_stack
13020                   == &VARRAY_TREE (current_lang_base, 0)))
13021             TYPE_FOR_JAVA (ref) = 1;
13022
13023           /* Note that the BINFO records which describe individual
13024              inheritances are *not* shared in the lattice!  They
13025              cannot be shared because a given baseclass may be
13026              inherited with different `accessibility' by different
13027              derived classes.  (Each BINFO record describing an
13028              individual inheritance contains flags which say what
13029              the `accessibility' of that particular inheritance is.)  */
13030
13031           base_binfo
13032             = make_binfo (size_zero_node, basetype,
13033                           CLASS_TYPE_P (basetype)
13034                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
13035                           CLASS_TYPE_P (basetype)
13036                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
13037
13038           TREE_VEC_ELT (binfos, i) = base_binfo;
13039           TREE_VIA_PUBLIC (base_binfo) = via_public;
13040           TREE_VIA_PROTECTED (base_binfo) = via_protected;
13041           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
13042           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
13043
13044           /* We need to unshare the binfos now so that lookups during class
13045              definition work.  */
13046           unshare_base_binfos (base_binfo);
13047
13048           SET_CLASSTYPE_MARKED (basetype);
13049
13050           /* We are free to modify these bits because they are meaningless
13051              at top level, and BASETYPE is a top-level type.  */
13052           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
13053             {
13054               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
13055               /* Converting to a virtual base class requires looking
13056                  up the offset of the virtual base.  */
13057               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13058             }
13059
13060           if (CLASS_TYPE_P (basetype))
13061             {
13062               TYPE_HAS_NEW_OPERATOR (ref)
13063                 |= TYPE_HAS_NEW_OPERATOR (basetype);
13064               TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
13065                 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
13066               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
13067               /* If the base-class uses multiple inheritance, so do we.  */
13068               TYPE_USES_MULTIPLE_INHERITANCE (ref)
13069                 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
13070               /* Likewise, if converting to a base of the base may require
13071                  code, then we may need to generate code to convert to a
13072                  base as well.  */
13073               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
13074                 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
13075             }
13076
13077           i += 1;
13078         }
13079     }
13080   if (i)
13081     TREE_VEC_LENGTH (binfos) = i;
13082   else
13083     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
13084
13085   if (i > 1)
13086     {
13087       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
13088       /* If there is more than one non-empty they cannot be at the same
13089          address.  */
13090       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13091     }
13092
13093   /* Unmark all the types.  */
13094   while (--i >= 0)
13095     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
13096   CLEAR_CLASSTYPE_MARKED (ref);
13097
13098   /* Now that we know all the base-classes, set up the list of virtual
13099      bases.  */
13100   get_vbase_types (ref);
13101 }
13102
13103 \f
13104 /* Begin compiling the definition of an enumeration type.
13105    NAME is its name (or null if anonymous).
13106    Returns the type object, as yet incomplete.
13107    Also records info about it so that build_enumerator
13108    may be used to declare the individual values as they are read.  */
13109
13110 tree
13111 start_enum (name)
13112      tree name;
13113 {
13114   register tree enumtype = NULL_TREE;
13115   struct binding_level *b = current_binding_level;
13116
13117   /* If this is the real definition for a previous forward reference,
13118      fill in the contents in the same object that used to be the
13119      forward reference.  */
13120
13121   if (name != NULL_TREE)
13122     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
13123
13124   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
13125     {
13126       cp_error ("multiple definition of `%#T'", enumtype);
13127       cp_error_at ("previous definition here", enumtype);
13128       /* Clear out TYPE_VALUES, and start again.  */
13129       TYPE_VALUES (enumtype) = NULL_TREE;
13130     }
13131   else
13132     {
13133       enumtype = make_node (ENUMERAL_TYPE);
13134       pushtag (name, enumtype, 0);
13135     }
13136
13137   if (current_class_type)
13138     TREE_ADDRESSABLE (b->tags) = 1;
13139
13140   GNU_xref_decl (current_function_decl, enumtype);
13141   return enumtype;
13142 }
13143
13144 /* After processing and defining all the values of an enumeration type,
13145    install their decls in the enumeration type and finish it off.
13146    ENUMTYPE is the type object and VALUES a list of name-value pairs.
13147    Returns ENUMTYPE.  */
13148
13149 tree
13150 finish_enum (enumtype)
13151      tree enumtype;
13152 {
13153   register tree minnode = NULL_TREE, maxnode = NULL_TREE;
13154   /* Calculate the maximum value of any enumerator in this type.  */
13155
13156   tree values = TYPE_VALUES (enumtype);
13157   if (values)
13158     {
13159       tree pair;
13160
13161       for (pair = values; pair; pair = TREE_CHAIN (pair))
13162         {
13163           tree decl;
13164           tree value;
13165
13166           /* The TREE_VALUE is a CONST_DECL for this enumeration
13167              constant.  */
13168           decl = TREE_VALUE (pair);
13169
13170           /* [dcl.enum]
13171
13172              Following the closing brace of an enum-specifier, each
13173              enumerator has the type of its enumeration.  Prior to the
13174              closing brace, the type of each enumerator is the type of
13175              its initializing value.  */
13176           TREE_TYPE (decl) = enumtype;
13177
13178           /* The DECL_INITIAL will be NULL if we are processing a
13179              template declaration and this enumeration constant had no
13180              explicit initializer.  */
13181           value = DECL_INITIAL (decl);
13182           if (value && !processing_template_decl)
13183             {
13184               /* Set the TREE_TYPE for the VALUE as well.  That's so
13185                  that when we call decl_constant_value we get an
13186                  entity of the right type (but with the constant
13187                  value).  Since we shouldn't ever call
13188                  decl_constant_value on a template type, there's no
13189                  reason to do that when processing_template_decl.
13190                  And, if the expression is something like a
13191                  TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will
13192                  wreak havoc on the intended type of the expression.
13193
13194                  Of course, there's also no point in trying to compute
13195                  minimum or maximum values if we're in a template.  */
13196               TREE_TYPE (value) = enumtype;
13197
13198               if (!minnode)
13199                 minnode = maxnode = value;
13200               else if (tree_int_cst_lt (maxnode, value))
13201                 maxnode = value;
13202               else if (tree_int_cst_lt (value, minnode))
13203                 minnode = value;
13204             }
13205
13206           if (processing_template_decl)
13207             /* If this is just a template, leave the CONST_DECL
13208                alone.  That way tsubst_copy will find CONST_DECLs for
13209                CONST_DECLs, and not INTEGER_CSTs.  */
13210             ;
13211           else
13212             /* In the list we're building up, we want the enumeration
13213                values, not the CONST_DECLs.  */
13214             TREE_VALUE (pair) = value;
13215         }
13216     }
13217   else
13218     maxnode = minnode = integer_zero_node;
13219
13220   TYPE_VALUES (enumtype) = nreverse (values);
13221
13222   if (processing_template_decl)
13223     {
13224       tree scope = current_scope ();
13225       if (scope && TREE_CODE (scope) == FUNCTION_DECL)
13226         add_tree (build_min (TAG_DEFN, enumtype));
13227     }
13228   else
13229     {
13230       int unsignedp = tree_int_cst_sgn (minnode) >= 0;
13231       int lowprec = min_precision (minnode, unsignedp);
13232       int highprec = min_precision (maxnode, unsignedp);
13233       int precision = MAX (lowprec, highprec);
13234       tree tem;
13235
13236       TYPE_SIZE (enumtype) = NULL_TREE;
13237
13238       /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
13239
13240       TYPE_PRECISION (enumtype) = precision;
13241       if (unsignedp)
13242         fixup_unsigned_type (enumtype);
13243       else
13244         fixup_signed_type (enumtype);
13245
13246       if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
13247         /* Use the width of the narrowest normal C type which is wide
13248            enough.  */
13249         TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
13250                                                     (precision, 1));
13251       else
13252         TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
13253
13254       TYPE_SIZE (enumtype) = 0;
13255       layout_type (enumtype);
13256
13257       /* Fix up all variant types of this enum type.  */
13258       for (tem = TYPE_MAIN_VARIANT (enumtype); tem;
13259            tem = TYPE_NEXT_VARIANT (tem))
13260         {
13261           TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
13262           TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
13263           TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
13264           TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
13265           TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
13266           TYPE_MODE (tem) = TYPE_MODE (enumtype);
13267           TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
13268           TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
13269           TYPE_USER_ALIGN (tem) = TYPE_USER_ALIGN (enumtype);
13270           TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
13271         }
13272
13273       /* Finish debugging output for this type.  */
13274       rest_of_type_compilation (enumtype, namespace_bindings_p ());
13275     }
13276
13277   return enumtype;
13278 }
13279
13280 /* Build and install a CONST_DECL for an enumeration constant of the
13281    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13282    Assignment of sequential values by default is handled here.  */
13283
13284 void
13285 build_enumerator (name, value, enumtype)
13286      tree name;
13287      tree value;
13288      tree enumtype;
13289 {
13290   tree decl;
13291   tree context;
13292   tree type;
13293   tree values;
13294
13295   /* Remove no-op casts from the value.  */
13296   if (value)
13297     STRIP_TYPE_NOPS (value);
13298
13299   if (! processing_template_decl)
13300     {
13301       /* Validate and default VALUE.  */
13302       if (value != NULL_TREE)
13303         {
13304           value = decl_constant_value (value);
13305
13306           if (TREE_CODE (value) == INTEGER_CST)
13307             {
13308               value = default_conversion (value);
13309               constant_expression_warning (value);
13310             }
13311           else
13312             {
13313               cp_error ("enumerator value for `%D' not integer constant", name);
13314               value = NULL_TREE;
13315             }
13316         }
13317
13318       /* Default based on previous value.  */
13319       if (value == NULL_TREE && ! processing_template_decl)
13320         {
13321           tree prev_value;
13322
13323           if (TYPE_VALUES (enumtype))
13324             {
13325               /* The next value is the previous value ... */
13326               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
13327               /* ... plus one.  */
13328               value = cp_build_binary_op (PLUS_EXPR,
13329                                           prev_value,
13330                                           integer_one_node);
13331
13332               if (tree_int_cst_lt (value, prev_value))
13333                 cp_error ("overflow in enumeration values at `%D'", name);
13334             }
13335           else
13336             value = integer_zero_node;
13337         }
13338
13339       /* Remove no-op casts from the value.  */
13340       if (value)
13341         STRIP_TYPE_NOPS (value);
13342 #if 0
13343       /* To fix MAX_VAL enum consts. (bkoz)  */
13344       TREE_TYPE (value) = integer_type_node;
13345 #endif
13346     }
13347
13348   /* We always have to copy here; not all INTEGER_CSTs are unshared.
13349      Even in other cases, we will later (in finish_enum) be setting
13350      the type of VALUE.  But, we don't need to make a copy if this
13351      VALUE is one of the enumeration constants for this same
13352      enumeration type.  */
13353   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
13354     if (TREE_VALUE (values) == value)
13355       break;
13356   /* If we didn't break out of the loop, then we do need a copy.  */
13357   if (!values && value)
13358     value = copy_node (value);
13359
13360   /* C++ associates enums with global, function, or class declarations.  */
13361   context = current_scope ();
13362
13363   /* Build the actual enumeration constant.  Note that the enumeration
13364     constants have the type of their initializers until the
13365     enumeration is complete:
13366
13367       [ dcl.enum ]
13368
13369       Following the closing brace of an enum-specifier, each enumer-
13370       ator has the type of its enumeration.  Prior to the closing
13371       brace, the type of each enumerator is the type of its
13372       initializing value.
13373
13374     In finish_enum we will reset the type.  Of course, if we're
13375     processing a template, there may be no value.   */
13376   type = value ? TREE_TYPE (value) : NULL_TREE;
13377
13378   if (context && context == current_class_type)
13379     /* This enum declaration is local to the class.  We need the full
13380       lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
13381     decl = build_lang_decl (CONST_DECL, name, type);
13382   else
13383     /* It's a global enum, or it's local to a function.  (Note local to
13384       a function could mean local to a class method.  */
13385     decl = build_decl (CONST_DECL, name, type);
13386
13387   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
13388   DECL_INITIAL (decl) = value;
13389   TREE_READONLY (decl) = 1;
13390
13391   if (context && context == current_class_type)
13392     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13393       on the TYPE_FIELDS list for `S'.  (That's so that you can say
13394       things like `S::i' later.)  */
13395     finish_member_declaration (decl);
13396   else
13397     {
13398       pushdecl (decl);
13399       GNU_xref_decl (current_function_decl, decl);
13400     }
13401
13402   /* Add this enumeration constant to the list for this type.  */
13403   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13404 }
13405
13406 \f
13407 static int function_depth;
13408
13409 /* We're defining DECL.  Make sure that it's type is OK.  */
13410
13411 static void
13412 check_function_type (decl)
13413      tree decl;
13414 {
13415   tree fntype = TREE_TYPE (decl);
13416   tree return_type = complete_type (TREE_TYPE (fntype));
13417
13418   /* In a function definition, arg types must be complete.  */
13419   require_complete_types_for_parms (current_function_parms);
13420
13421   if (!COMPLETE_OR_VOID_TYPE_P (return_type))
13422     {
13423       cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
13424
13425       /* Make it return void instead, but don't change the
13426          type of the DECL_RESULT, in case we have a named return value.  */
13427       if (TREE_CODE (fntype) == METHOD_TYPE)
13428         {
13429           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
13430           TREE_TYPE (decl)
13431             = build_cplus_method_type (ctype,
13432                                        void_type_node,
13433                                        FUNCTION_ARG_CHAIN (decl));
13434         }
13435       else
13436         TREE_TYPE (decl)
13437           = build_function_type (void_type_node,
13438                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
13439       TREE_TYPE (decl)
13440         = build_exception_variant (fntype,
13441                                    TYPE_RAISES_EXCEPTIONS (fntype));
13442     }
13443   else
13444     abstract_virtuals_error (decl, TREE_TYPE (fntype));
13445 }
13446
13447 /* Create the FUNCTION_DECL for a function definition.
13448    DECLSPECS and DECLARATOR are the parts of the declaration;
13449    they describe the function's name and the type it returns,
13450    but twisted together in a fashion that parallels the syntax of C.
13451
13452    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13453    DECLARATOR is really the DECL for the function we are about to
13454    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13455    indicating that the function is an inline defined in-class, and
13456    SF_EXPAND indicating that we should generate RTL for this
13457    function.
13458
13459    This function creates a binding context for the function body
13460    as well as setting up the FUNCTION_DECL in current_function_decl.
13461
13462    Returns 1 on success.  If the DECLARATOR is not suitable for a function
13463    (it defines a datum instead), we return 0, which tells
13464    yyparse to report a parse error.
13465
13466    For C++, we must first check whether that datum makes any sense.
13467    For example, "class A local_a(1,2);" means that variable local_a
13468    is an aggregate of type A, which should have a constructor
13469    applied to it with the argument list [1, 2].  */
13470
13471 int
13472 start_function (declspecs, declarator, attrs, flags)
13473      tree declspecs, declarator, attrs;
13474      int flags;
13475 {
13476   tree decl1;
13477   tree ctype = NULL_TREE;
13478   tree fntype;
13479   tree restype;
13480   extern int have_extern_spec;
13481   extern int used_extern_spec;
13482   int doing_friend = 0;
13483   struct binding_level *bl;
13484
13485   /* Sanity check.  */
13486   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
13487   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
13488
13489   /* This should only be done once on the top most decl.  */
13490   if (have_extern_spec && !used_extern_spec)
13491     {
13492       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
13493       used_extern_spec = 1;
13494     }
13495
13496   if (flags & SF_PRE_PARSED)
13497     {
13498       decl1 = declarator;
13499
13500       fntype = TREE_TYPE (decl1);
13501       if (TREE_CODE (fntype) == METHOD_TYPE)
13502         ctype = TYPE_METHOD_BASETYPE (fntype);
13503
13504       /* ISO C++ 11.4/5.  A friend function defined in a class is in
13505          the (lexical) scope of the class in which it is defined.  */
13506       if (!ctype && DECL_FRIEND_P (decl1))
13507         {
13508           ctype = DECL_FRIEND_CONTEXT (decl1);
13509
13510           /* CTYPE could be null here if we're dealing with a template;
13511              for example, `inline friend float foo()' inside a template
13512              will have no CTYPE set.  */
13513           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13514             ctype = NULL_TREE;
13515           else
13516             doing_friend = 1;
13517         }
13518
13519       last_function_parms = DECL_ARGUMENTS (decl1);
13520       last_function_parm_tags = NULL_TREE;
13521     }
13522   else
13523     {
13524       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL_TREE);
13525       /* If the declarator is not suitable for a function definition,
13526          cause a syntax error.  */
13527       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
13528
13529       fntype = TREE_TYPE (decl1);
13530
13531       restype = TREE_TYPE (fntype);
13532       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13533         {
13534           cp_error ("semicolon missing after declaration of `%#T'", restype);
13535           shadow_tag (build_tree_list (NULL_TREE, restype));
13536           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13537           if (TREE_CODE (fntype) == FUNCTION_TYPE)
13538             fntype = build_function_type (integer_type_node,
13539                                           TYPE_ARG_TYPES (fntype));
13540           else
13541             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13542                                               integer_type_node,
13543                                               TYPE_ARG_TYPES (fntype));
13544           TREE_TYPE (decl1) = fntype;
13545         }
13546
13547       if (TREE_CODE (fntype) == METHOD_TYPE)
13548         ctype = TYPE_METHOD_BASETYPE (fntype);
13549       else if (DECL_MAIN_P (decl1))
13550         {
13551           /* If this doesn't return integer_type, complain.  */
13552           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13553             {
13554               if (pedantic || warn_return_type)
13555                 pedwarn ("return type for `main' changed to `int'");
13556               TREE_TYPE (decl1) = fntype = default_function_type;
13557             }
13558         }
13559     }
13560
13561   /* Sometimes we don't notice that a function is a static member, and
13562      build a METHOD_TYPE for it.  Fix that up now.  */
13563   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13564       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13565     {
13566       revert_static_member_fn (decl1);
13567       last_function_parms = TREE_CHAIN (last_function_parms);
13568       ctype = NULL_TREE;
13569     }
13570
13571   /* Warn if function was previously implicitly declared
13572      (but not if we warned then).  */
13573   if (! warn_implicit
13574       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13575     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13576
13577   /* Set up current_class_type, and enter the scope of the class, if
13578      appropriate.  */
13579   if (ctype)
13580     push_nested_class (ctype, 1);
13581   else if (DECL_STATIC_FUNCTION_P (decl1))
13582     push_nested_class (DECL_CONTEXT (decl1), 2);
13583
13584   /* Now that we have entered the scope of the class, we must restore
13585      the bindings for any template parameters surrounding DECL1, if it
13586      is an inline member template.  (Order is important; consider the
13587      case where a template parameter has the same name as a field of
13588      the class.)  It is not until after this point that
13589      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
13590   if (flags & SF_INCLASS_INLINE)
13591     maybe_begin_member_template_processing (decl1);
13592
13593   /* Effective C++ rule 15.  See also c_expand_return.  */
13594   if (warn_ecpp
13595       && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
13596       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13597     cp_warning ("`operator=' should return a reference to `*this'");
13598
13599   /* Make the init_value nonzero so pushdecl knows this is not tentative.
13600      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
13601   if (!DECL_INITIAL (decl1))
13602     DECL_INITIAL (decl1) = error_mark_node;
13603
13604 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
13605   SET_DEFAULT_DECL_ATTRIBUTES (decl1, attrs);
13606 #endif
13607
13608   /* This function exists in static storage.
13609      (This does not mean `static' in the C sense!)  */
13610   TREE_STATIC (decl1) = 1;
13611
13612   /* We must call push_template_decl after current_class_type is set
13613      up.  (If we are processing inline definitions after exiting a
13614      class scope, current_class_type will be NULL_TREE until set above
13615      by push_nested_class.)  */
13616   if (processing_template_decl)
13617     decl1 = push_template_decl (decl1);
13618
13619   /* We are now in the scope of the function being defined.  */
13620   current_function_decl = decl1;
13621
13622   /* Save the parm names or decls from this function's declarator
13623      where store_parm_decls will find them.  */
13624   current_function_parms = last_function_parms;
13625   current_function_parm_tags = last_function_parm_tags;
13626
13627   /* Make sure the parameter and return types are reasonable.  When
13628      you declare a function, these types can be incomplete, but they
13629      must be complete when you define the function.  */
13630   if (! processing_template_decl)
13631     check_function_type (decl1);
13632
13633   /* Build the return declaration for the function.  */
13634   restype = TREE_TYPE (fntype);
13635   if (!processing_template_decl)
13636     {
13637       if (!DECL_RESULT (decl1))
13638         {
13639           DECL_RESULT (decl1)
13640             = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13641           c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype),
13642                                       DECL_RESULT (decl1));
13643         }
13644     }
13645   else
13646     /* Just use `void'.  Nobody will ever look at this anyhow.  */
13647     DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, void_type_node);
13648
13649   /* Initialize RTL machinery.  We cannot do this until
13650      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
13651      even when processing a template; this is how we get
13652      CFUN set up, and our per-function variables initialized.  */
13653   bl = current_binding_level;
13654   init_function_start (decl1, input_filename, lineno);
13655   current_binding_level = bl;
13656   expanding_p = (flags & SF_EXPAND) != 0;
13657
13658   /* Even though we're inside a function body, we still don't want to
13659      call expand_expr to calculate the size of a variable-sized array.
13660      We haven't necessarily assigned RTL to all variables yet, so it's
13661      not safe to try to expand expressions involving them.  */
13662   immediate_size_expand = 0;
13663   cfun->x_dont_save_pending_sizes_p = 1;
13664
13665   /* If we're building a statement-tree, start the tree now.  */
13666   if (processing_template_decl || !expanding_p)
13667     begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13668
13669   /* Let the user know we're compiling this function.  */
13670   announce_function (decl1);
13671
13672   /* Record the decl so that the function name is defined.
13673      If we already have a decl for this name, and it is a FUNCTION_DECL,
13674      use the old decl.  */
13675   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13676     {
13677       /* A specialization is not used to guide overload resolution.  */
13678       if (!DECL_TEMPLATE_SPECIALIZATION (decl1)
13679           && ! DECL_FUNCTION_MEMBER_P (decl1))
13680         decl1 = pushdecl (decl1);
13681       else
13682         {
13683           /* We need to set the DECL_CONTEXT. */
13684           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13685             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13686           /* And make sure we have enough default args.  */
13687           check_default_args (decl1);
13688         }
13689       fntype = TREE_TYPE (decl1);
13690     }
13691
13692   /* Reset these in case the call to pushdecl changed them.  */
13693   current_function_decl = decl1;
13694   cfun->decl = decl1;
13695
13696   /* Initialize the per-function data.  */
13697   if (!DECL_PENDING_INLINE_P (decl1) && DECL_SAVED_FUNCTION_DATA (decl1))
13698     {
13699       /* If we already parsed this function, and we're just expanding it
13700          now, restore saved state.  */
13701       struct binding_level *bl = current_binding_level;
13702       *cp_function_chain = *DECL_SAVED_FUNCTION_DATA (decl1);
13703       current_binding_level = bl;
13704
13705       /* This function is being processed in whole-function mode; we
13706          already did semantic analysis.  */
13707       cfun->x_whole_function_mode_p = 1;
13708
13709       /* If we decided that we didn't want to inline this function,
13710          make sure the back-end knows that.  */
13711       if (!current_function_cannot_inline)
13712         current_function_cannot_inline = cp_function_chain->cannot_inline;
13713
13714       /* We don't need the saved data anymore.  */
13715       free (DECL_SAVED_FUNCTION_DATA (decl1));
13716       DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13717     }
13718   else if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13719     {
13720       /* We know that this was set up by `grokclassfn'.  We do not
13721          wait until `store_parm_decls', since evil parse errors may
13722          never get us to that point.  Here we keep the consistency
13723          between `current_class_type' and `current_class_ptr'.  */
13724       tree t = DECL_ARGUMENTS (decl1);
13725
13726       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13727                           162);
13728       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13729                           19990811);
13730
13731       cp_function_chain->x_current_class_ref
13732         = build_indirect_ref (t, NULL_PTR);
13733       cp_function_chain->x_current_class_ptr = t;
13734
13735       /* Constructors and destructors need to know whether they're "in
13736          charge" of initializing virtual base classes.  */
13737       if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
13738         current_in_charge_parm = TREE_CHAIN (t);
13739     }
13740
13741   if (DECL_INTERFACE_KNOWN (decl1))
13742     {
13743       tree ctx = decl_function_context (decl1);
13744
13745       if (DECL_NOT_REALLY_EXTERN (decl1))
13746         DECL_EXTERNAL (decl1) = 0;
13747
13748       if (ctx != NULL_TREE && DECL_THIS_INLINE (ctx)
13749           && TREE_PUBLIC (ctx))
13750         /* This is a function in a local class in an extern inline
13751            function.  */
13752         comdat_linkage (decl1);
13753     }
13754   /* If this function belongs to an interface, it is public.
13755      If it belongs to someone else's interface, it is also external.
13756      This only affects inlines and template instantiations.  */
13757   else if (interface_unknown == 0
13758            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13759                || flag_alt_external_templates))
13760     {
13761       if (DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1)
13762           || processing_template_decl)
13763         {
13764           DECL_EXTERNAL (decl1)
13765             = (interface_only
13766                || (DECL_THIS_INLINE (decl1) && ! flag_implement_inlines
13767                    && !DECL_VINDEX (decl1)));
13768
13769           /* For WIN32 we also want to put these in linkonce sections.  */
13770           maybe_make_one_only (decl1);
13771         }
13772       else
13773         DECL_EXTERNAL (decl1) = 0;
13774       DECL_NOT_REALLY_EXTERN (decl1) = 0;
13775       DECL_INTERFACE_KNOWN (decl1) = 1;
13776     }
13777   else if (interface_unknown && interface_only
13778            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13779                || flag_alt_external_templates))
13780     {
13781       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13782          interface, we will have interface_only set but not
13783          interface_known.  In that case, we don't want to use the normal
13784          heuristics because someone will supply a #pragma implementation
13785          elsewhere, and deducing it here would produce a conflict.  */
13786       comdat_linkage (decl1);
13787       DECL_EXTERNAL (decl1) = 0;
13788       DECL_INTERFACE_KNOWN (decl1) = 1;
13789       DECL_DEFER_OUTPUT (decl1) = 1;
13790     }
13791   else
13792     {
13793       /* This is a definition, not a reference.
13794          So clear DECL_EXTERNAL.  */
13795       DECL_EXTERNAL (decl1) = 0;
13796
13797       if ((DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1))
13798           && ! DECL_INTERFACE_KNOWN (decl1)
13799           /* Don't try to defer nested functions for now.  */
13800           && ! decl_function_context (decl1))
13801         DECL_DEFER_OUTPUT (decl1) = 1;
13802       else
13803         DECL_INTERFACE_KNOWN (decl1) = 1;
13804     }
13805
13806   if (doing_semantic_analysis_p ())
13807     {
13808       pushlevel (0);
13809       current_binding_level->parm_flag = 1;
13810     }
13811
13812   if (attrs)
13813     cplus_decl_attributes (decl1, NULL_TREE, attrs);
13814
13815   if (!building_stmt_tree ())
13816     {
13817       GNU_xref_function (decl1, current_function_parms);
13818       make_function_rtl (decl1);
13819     }
13820
13821   /* Promote the value to int before returning it.  */
13822   if (C_PROMOTING_INTEGER_TYPE_P (restype))
13823     restype = type_promotes_to (restype);
13824
13825   /* If this fcn was already referenced via a block-scope `extern' decl
13826      (or an implicit decl), propagate certain information about the usage.  */
13827   if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1)))
13828     TREE_ADDRESSABLE (decl1) = 1;
13829
13830   if (DECL_RESULT (decl1) == NULL_TREE)
13831     {
13832       DECL_RESULT (decl1)
13833         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13834       TREE_READONLY (DECL_RESULT (decl1)) = CP_TYPE_CONST_P (restype);
13835       TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = CP_TYPE_VOLATILE_P (restype);
13836     }
13837
13838   ++function_depth;
13839
13840   if (DECL_DESTRUCTOR_P (decl1))
13841     {
13842       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13843       DECL_CONTEXT (dtor_label) = current_function_decl;
13844     }
13845   /* Under the old ABI we return `this' from constructors, so we make
13846      ordinary `return' statements in constructors jump to CTOR_LABEL;
13847      from there we return `this'.  Under the new ABI, we don't bother
13848      with any of this.  By not setting CTOR_LABEL the remainder of the
13849      machinery is automatically disabled.  */
13850   else if (!flag_new_abi && DECL_CONSTRUCTOR_P (decl1))
13851     {
13852       ctor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13853       DECL_CONTEXT (ctor_label) = current_function_decl;
13854     }
13855
13856   return 1;
13857 }
13858 \f
13859 /* Called after store_parm_decls for a function-try-block.  */
13860
13861 void
13862 expand_start_early_try_stmts ()
13863 {
13864   expand_start_try_stmts ();
13865 }
13866
13867 /* Store the parameter declarations into the current function declaration.
13868    This is called after parsing the parameter declarations, before
13869    digesting the body of the function.
13870
13871    Also install to binding contour return value identifier, if any.  */
13872
13873 void
13874 store_parm_decls ()
13875 {
13876   register tree fndecl = current_function_decl;
13877   register tree parm;
13878   int parms_have_cleanups = 0;
13879   tree cleanups = NULL_TREE;
13880
13881   /* This is a list of types declared among parms in a prototype.  */
13882   tree parmtags = current_function_parm_tags;
13883
13884   /* This is a chain of any other decls that came in among the parm
13885      declarations.  If a parm is declared with  enum {foo, bar} x;
13886      then CONST_DECLs for foo and bar are put here.  */
13887   tree nonparms = NULL_TREE;
13888
13889   /* Create a binding level for the parms.  */
13890   if (!building_stmt_tree ())
13891     expand_start_bindings (2);
13892
13893   if (current_function_parms)
13894     {
13895       /* This case is when the function was defined with an ANSI prototype.
13896          The parms already have decls, so we need not do anything here
13897          except record them as in effect
13898          and complain if any redundant old-style parm decls were written.  */
13899
13900       tree specparms = current_function_parms;
13901       tree next;
13902
13903       if (doing_semantic_analysis_p ())
13904         {
13905           /* Must clear this because it might contain TYPE_DECLs declared
13906              at class level.  */
13907           storedecls (NULL_TREE);
13908
13909           /* If we're doing semantic analysis, then we'll call pushdecl
13910              for each of these.  We must do them in reverse order so that
13911              they end in the correct forward order.  */
13912           specparms = nreverse (specparms);
13913         }
13914
13915       for (parm = specparms; parm; parm = next)
13916         {
13917           next = TREE_CHAIN (parm);
13918           if (TREE_CODE (parm) == PARM_DECL)
13919             {
13920               tree type = TREE_TYPE (parm);
13921
13922               if (doing_semantic_analysis_p ())
13923                 {
13924                   tree cleanup;
13925
13926                   if (DECL_NAME (parm) == NULL_TREE
13927                       || TREE_CODE (parm) != VOID_TYPE)
13928                     pushdecl (parm);
13929                   else
13930                     cp_error ("parameter `%D' declared void", parm);
13931
13932                   cleanup = (processing_template_decl
13933                              ? NULL_TREE
13934                              : maybe_build_cleanup (parm));
13935
13936                   if (cleanup)
13937                     cleanups = tree_cons (parm, cleanup, cleanups);
13938                 }
13939               else if (type != error_mark_node
13940                        && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
13941                 parms_have_cleanups = 1;
13942             }
13943           else
13944             {
13945               /* If we find an enum constant or a type tag,
13946                  put it aside for the moment.  */
13947               TREE_CHAIN (parm) = NULL_TREE;
13948               nonparms = chainon (nonparms, parm);
13949             }
13950         }
13951
13952       if (doing_semantic_analysis_p ())
13953         {
13954           /* Get the decls in their original chain order
13955              and record in the function.  This is all and only the
13956              PARM_DECLs that were pushed into scope by the loop above.  */
13957           DECL_ARGUMENTS (fndecl) = getdecls ();
13958           storetags (chainon (parmtags, gettags ()));
13959         }
13960     }
13961   else
13962     DECL_ARGUMENTS (fndecl) = NULL_TREE;
13963
13964   /* Now store the final chain of decls for the arguments
13965      as the decl-chain of the current lexical scope.
13966      Put the enumerators in as well, at the front so that
13967      DECL_ARGUMENTS is not modified.  */
13968   if (doing_semantic_analysis_p ())
13969     storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
13970
13971   /* Initialize the RTL code for the function.  */
13972   DECL_SAVED_INSNS (fndecl) = 0;
13973   if (! building_stmt_tree ())
13974     expand_function_start (fndecl, parms_have_cleanups);
13975
13976   current_function_parms_stored = 1;
13977
13978   /* If this function is `main', emit a call to `__main'
13979      to run global initializers, etc.  */
13980   if (DECL_MAIN_P (fndecl) && !building_stmt_tree ())
13981     expand_main_function ();
13982
13983   /* Now that we have initialized the parms, we can start their
13984      cleanups.  We cannot do this before, since expand_decl_cleanup
13985      should not be called before the parm can be used.  */
13986   while (cleanups)
13987     {
13988       finish_decl_cleanup (TREE_PURPOSE (cleanups),
13989                            TREE_VALUE (cleanups));
13990       cleanups = TREE_CHAIN (cleanups);
13991     }
13992
13993   /* Create a binding contour which can be used to catch
13994      cleanup-generated temporaries.  Also, if the return value needs or
13995      has initialization, deal with that now.  */
13996   if (parms_have_cleanups)
13997     {
13998       pushlevel (0);
13999       if (!building_stmt_tree ())
14000         expand_start_bindings (2);
14001     }
14002
14003   /* Do the starting of the exception specifications, if we have any.  */
14004   if (flag_exceptions && !processing_template_decl
14005       && flag_enforce_eh_specs
14006       && building_stmt_tree ()
14007       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14008     current_eh_spec_try_block = expand_start_eh_spec ();
14009 }
14010
14011 /* Bind a name and initialization to the return value of
14012    the current function.  */
14013
14014 void
14015 store_return_init (decl)
14016      tree decl;
14017 {
14018   /* If this named return value comes in a register, put it in a
14019      pseudo-register.  */
14020   if (DECL_REGISTER (decl))
14021     {
14022       original_result_rtx = DECL_RTL (decl);
14023       /* Note that the mode of the old DECL_RTL may be wider than the
14024          mode of DECL_RESULT, depending on the calling conventions for
14025          the processor.  For example, on the Alpha, a 32-bit integer
14026          is returned in a DImode register -- the DECL_RESULT has
14027          SImode but the DECL_RTL for the DECL_RESULT has DImode.  So,
14028          here, we use the mode the back-end has already assigned for
14029          the return value.  */
14030       DECL_RTL (decl) = gen_reg_rtx (GET_MODE (original_result_rtx));
14031       if (TREE_ADDRESSABLE (decl))
14032         put_var_into_stack (decl);
14033     }
14034 }
14035
14036 \f
14037 /* We have finished doing semantic analysis on DECL, but have not yet
14038    generated RTL for its body.  Save away our current state, so that
14039    when we want to generate RTL later we know what to do.  */
14040
14041 static void
14042 save_function_data (decl)
14043      tree decl;
14044 {
14045   struct language_function *f;
14046
14047   /* Save the language-specific per-function data so that we can
14048      get it back when we really expand this function.  */
14049   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
14050                       19990908);
14051
14052   /* Make a copy.  */
14053   f = ((struct language_function *)
14054        xmalloc (sizeof (struct language_function)));
14055   bcopy ((char *) cp_function_chain, (char *) f,
14056          sizeof (struct language_function));
14057   DECL_SAVED_FUNCTION_DATA (decl) = f;
14058
14059   /* Clear out the bits we don't need.  */
14060   f->x_stmt_tree.x_last_stmt = NULL_TREE;
14061   f->x_stmt_tree.x_last_expr_type = NULL_TREE;
14062   f->x_result_rtx = NULL_RTX;
14063   f->x_named_label_uses = NULL;
14064   f->bindings = NULL;
14065
14066   /* When we get back here again, we will be expanding.  */
14067   f->x_expanding_p = 1;
14068
14069   /* If we've already decided that we cannot inline this function, we
14070      must remember that fact when we actually go to expand the
14071      function.  */
14072   f->cannot_inline = current_function_cannot_inline;
14073 }
14074
14075 /* At the end of every constructor we generate to code to return
14076    `this'.  Do that now.  */
14077
14078 static void
14079 finish_constructor_body ()
14080 {
14081   /* Any return from a constructor will end up here.  */
14082   if (ctor_label)
14083     add_tree (build_min_nt (LABEL_STMT, ctor_label));
14084
14085   /* Clear CTOR_LABEL so that finish_return_stmt knows to really
14086      generate the return, rather than a goto to CTOR_LABEL.  */
14087   ctor_label = NULL_TREE;
14088   /* In check_return_expr we translate an empty return from a
14089      constructor to a return of `this'.  */
14090   finish_return_stmt (NULL_TREE);
14091   /* Mark the end of the constructor.  */
14092   add_tree (build_min_nt (CTOR_STMT));
14093 }
14094
14095 /* At the end of every destructor we generate code to restore virtual
14096    function tables to the values desired by base classes and to call
14097    to base class destructors.  Do that now.  */
14098
14099 static void
14100 finish_destructor_body ()
14101 {
14102   tree compound_stmt;
14103   tree virtual_size;
14104   tree exprstmt;
14105   tree if_stmt;
14106
14107   /* Create a block to contain all the extra code.  */
14108   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
14109
14110   /* Any return from a destructor will end up here.  */
14111   add_tree (build_min_nt (LABEL_STMT, dtor_label));
14112
14113   /* Generate the code to call destructor on base class.  If this
14114      destructor belongs to a class with virtual functions, then set
14115      the virtual function table pointer to represent the type of our
14116      base class.  */
14117
14118   /* This side-effect makes call to `build_delete' generate the code
14119      we have to have at the end of this destructor.  `build_delete'
14120      will set the flag again.  */
14121   TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
14122
14123   exprstmt = build_delete (current_class_type,
14124                            current_class_ref,
14125                            sfk_base_destructor,
14126                            LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
14127                            0);
14128
14129   if (exprstmt != error_mark_node
14130       && (TREE_CODE (exprstmt) != NOP_EXPR
14131           || TREE_OPERAND (exprstmt, 0) != integer_zero_node
14132           || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
14133     {
14134       if (exprstmt != void_zero_node)
14135         /* Don't call `expand_expr_stmt' if we're not going to do
14136            anything, since -Wall will give a diagnostic.  */
14137         finish_expr_stmt (exprstmt);
14138
14139       /* Run destructors for all virtual baseclasses.  */
14140       if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
14141         {
14142           tree vbases;
14143           tree if_stmt;
14144
14145           if_stmt = begin_if_stmt ();
14146           finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
14147                                       current_in_charge_parm,
14148                                       integer_two_node),
14149                                if_stmt);
14150
14151           vbases = CLASSTYPE_VBASECLASSES (current_class_type);
14152           /* The CLASSTYPE_VBASECLASSES list is in initialization
14153              order, so we have to march through it in reverse order.  */
14154           for (vbases = nreverse (copy_list (vbases));
14155                vbases;
14156                vbases = TREE_CHAIN (vbases))
14157             {
14158               tree vbase = TREE_VALUE (vbases);
14159
14160               if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (vbase)))
14161                 {
14162                   tree vb = get_vbase
14163                     (BINFO_TYPE (vbase),
14164                      TYPE_BINFO (current_class_type));
14165                   finish_expr_stmt
14166                     (build_scoped_method_call
14167                      (current_class_ref, vb, base_dtor_identifier,
14168                       NULL_TREE));
14169                 }
14170             }
14171
14172           finish_then_clause (if_stmt);
14173           finish_if_stmt ();
14174         }
14175     }
14176
14177   virtual_size = c_sizeof (current_class_type);
14178
14179   /* At the end, call delete if that's what's requested.  */
14180
14181   /* FDIS sez: At the point of definition of a virtual destructor
14182      (including an implicit definition), non-placement operator delete
14183      shall be looked up in the scope of the destructor's class and if
14184      found shall be accessible and unambiguous.
14185
14186      This is somewhat unclear, but I take it to mean that if the class
14187      only defines placement deletes we don't do anything here.  So we
14188      pass LOOKUP_SPECULATIVELY; delete_sanity will complain for us if
14189      they ever try to delete one of these.  */
14190   exprstmt = build_op_delete_call
14191     (DELETE_EXPR, current_class_ptr, virtual_size,
14192      LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
14193
14194   if_stmt = begin_if_stmt ();
14195   finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
14196                               current_in_charge_parm,
14197                               integer_one_node),
14198                        if_stmt);
14199   finish_expr_stmt (exprstmt);
14200   finish_then_clause (if_stmt);
14201   finish_if_stmt ();
14202
14203   /* Close the block we started above.  */
14204   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
14205 }
14206
14207 /* Finish up a function declaration and compile that function
14208    all the way to assembler language output.  The free the storage
14209    for the function definition.
14210
14211    FLAGS is a bitwise or of the following values:
14212      1 - CALL_POPLEVEL
14213        An extra call to poplevel (and expand_end_bindings) must be
14214        made to take care of the binding contour for the base
14215        initializers.  This is only relevant for constructors.
14216      2 - INCLASS_INLINE
14217        We just finished processing the body of an in-class inline
14218        function definition.  (This processing will have taken place
14219        after the class definition is complete.)  */
14220
14221 tree
14222 finish_function (flags)
14223      int flags;
14224 {
14225   register tree fndecl = current_function_decl;
14226   tree fntype, ctype = NULL_TREE;
14227   /* Label to use if this function is supposed to return a value.  */
14228   tree no_return_label = NULL_TREE;
14229   int call_poplevel = (flags & 1) != 0;
14230   int inclass_inline = (flags & 2) != 0;
14231   int expand_p;
14232   int nested;
14233   int current_line = lineno;
14234
14235   /* When we get some parse errors, we can end up without a
14236      current_function_decl, so cope.  */
14237   if (fndecl == NULL_TREE)
14238     return error_mark_node;
14239
14240   nested = function_depth > 1;
14241   fntype = TREE_TYPE (fndecl);
14242
14243   /*  TREE_READONLY (fndecl) = 1;
14244       This caused &foo to be of type ptr-to-const-function
14245       which then got a warning when stored in a ptr-to-function variable.  */
14246
14247   /* This happens on strange parse errors.  */
14248   if (! current_function_parms_stored)
14249     {
14250       call_poplevel = 0;
14251       store_parm_decls ();
14252     }
14253
14254   /* For a cloned function, we've already got all the code we need;
14255      there's no need to add any extra bits.  */
14256   if (building_stmt_tree () && DECL_CLONED_FUNCTION_P (fndecl))
14257     ;
14258   else if (building_stmt_tree ())
14259     {
14260       if (DECL_CONSTRUCTOR_P (fndecl))
14261         {
14262           finish_constructor_body ();
14263           if (call_poplevel)
14264             do_poplevel ();
14265         }
14266       else if (DECL_DESTRUCTOR_P (fndecl) && !processing_template_decl)
14267         finish_destructor_body ();
14268       else if (DECL_MAIN_P (fndecl))
14269         {
14270           /* Make it so that `main' always returns 0 by default.  */
14271 #ifdef VMS
14272           finish_return_stmt (integer_one_node);
14273 #else
14274           finish_return_stmt (integer_zero_node);
14275 #endif
14276         }
14277
14278       /* Finish dealing with exception specifiers.  */
14279       if (flag_exceptions && !processing_template_decl
14280           && flag_enforce_eh_specs
14281           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14282         expand_end_eh_spec (TYPE_RAISES_EXCEPTIONS
14283                             (TREE_TYPE (current_function_decl)),
14284                             current_eh_spec_try_block);
14285     }
14286   else
14287     {
14288 #if 0
14289       if (write_symbols != NO_DEBUG /*&& TREE_CODE (fntype) != METHOD_TYPE*/)
14290         {
14291           /* Keep this code around in case we later want to control debug info
14292              based on whether a type is "used".  (jason 1999-11-11) */
14293
14294           tree ttype = target_type (fntype);
14295           tree parmdecl;
14296
14297           if (IS_AGGR_TYPE (ttype))
14298             /* Let debugger know it should output info for this type.  */
14299             note_debug_info_needed (ttype);
14300
14301           for (parmdecl = DECL_ARGUMENTS (fndecl); parmdecl; parmdecl = TREE_CHAIN (parmdecl))
14302             {
14303               ttype = target_type (TREE_TYPE (parmdecl));
14304               if (IS_AGGR_TYPE (ttype))
14305                 /* Let debugger know it should output info for this type.  */
14306                 note_debug_info_needed (ttype);
14307             }
14308         }
14309 #endif
14310
14311       /* Clean house because we will need to reorder insns here.  */
14312       do_pending_stack_adjust ();
14313
14314       if (dtor_label)
14315         ;
14316       else if (DECL_CONSTRUCTOR_P (fndecl))
14317         {
14318           if (call_poplevel)
14319             do_poplevel ();
14320         }
14321       else if (return_label != NULL_RTX
14322                && flag_this_is_variable <= 0
14323                && current_function_return_value == NULL_TREE
14324                && ! DECL_NAME (DECL_RESULT (current_function_decl)))
14325         no_return_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
14326
14327       if (flag_exceptions)
14328         expand_exception_blocks ();
14329
14330       /* If this function is supposed to return a value, ensure that
14331          we do not fall into the cleanups by mistake.  The end of our
14332          function will look like this:
14333
14334          user code (may have return stmt somewhere)
14335          goto no_return_label
14336          cleanup_label:
14337          cleanups
14338          goto return_label
14339          no_return_label:
14340          NOTE_INSN_FUNCTION_END
14341          return_label:
14342          things for return
14343
14344          If the user omits a return stmt in the USER CODE section, we
14345          will have a control path which reaches NOTE_INSN_FUNCTION_END.
14346          Otherwise, we won't.  */
14347       if (no_return_label)
14348         {
14349           DECL_CONTEXT (no_return_label) = fndecl;
14350           DECL_INITIAL (no_return_label) = error_mark_node;
14351           DECL_SOURCE_FILE (no_return_label) = input_filename;
14352           DECL_SOURCE_LINE (no_return_label) = current_line;
14353           expand_goto (no_return_label);
14354         }
14355
14356       if (cleanup_label)
14357         {
14358           /* Remove the binding contour which is used
14359              to catch cleanup-generated temporaries.  */
14360           expand_end_bindings (0, 0, 0);
14361           poplevel (0, 0, 0);
14362
14363           /* Emit label at beginning of cleanup code for parameters.  */
14364           emit_label (cleanup_label);
14365         }
14366
14367       /* Get return value into register if that's where it's supposed
14368          to be.  */
14369       if (original_result_rtx)
14370         fixup_result_decl (DECL_RESULT (fndecl), original_result_rtx);
14371
14372       /* Finish building code that will trigger warnings if users forget
14373          to make their functions return values.  */
14374       if (no_return_label || cleanup_label)
14375         emit_jump (return_label);
14376       if (no_return_label)
14377         {
14378           /* We don't need to call `expand_*_return' here because we
14379              don't need any cleanups here--this path of code is only
14380              for error checking purposes.  */
14381           expand_label (no_return_label);
14382         }
14383
14384       /* We hard-wired immediate_size_expand to zero in
14385          start_function.  Expand_function_end will decrement this
14386          variable.  So, we set the variable to one here, so that after
14387          the decrement it will remain zero.  */
14388       immediate_size_expand = 1;
14389
14390       /* Generate rtl for function exit.  */
14391       expand_function_end (input_filename, current_line, 1);
14392     }
14393
14394   /* We have to save this value here in case
14395      maybe_end_member_template_processing decides to pop all the
14396      template parameters.  */
14397   expand_p = !building_stmt_tree ();
14398
14399   /* If we're saving up tree structure, tie off the function now.  */
14400   if (!expand_p)
14401     finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
14402
14403   /* This must come after expand_function_end because cleanups might
14404      have declarations (from inline functions) that need to go into
14405      this function's blocks.  */
14406   if (doing_semantic_analysis_p ())
14407     {
14408       if (current_binding_level->parm_flag != 1)
14409         my_friendly_abort (122);
14410       poplevel (1, 0, 1);
14411     }
14412
14413   /* Remember that we were in class scope.  */
14414   if (current_class_name)
14415     ctype = current_class_type;
14416
14417   /* Must mark the RESULT_DECL as being in this function.  */
14418   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
14419
14420   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14421      to the FUNCTION_DECL node itself.  */
14422   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
14423
14424   /* Save away current state, if appropriate.  */
14425   if (!expanding_p && !processing_template_decl)
14426     save_function_data (fndecl);
14427
14428   /* If this function calls `setjmp' it cannot be inlined.  When
14429      `longjmp' is called it is not guaranteed to restore the value of
14430      local variables that have been modified since the call to
14431      `setjmp'.  So, if were to inline this function into some caller
14432      `c', then when we `longjmp', we might not restore all variables
14433      in `c'.  (It might seem, at first blush, that there's no way for
14434      this function to modify local variables in `c', but their
14435      addresses may have been stored somewhere accessible to this
14436      function.)  */
14437   if (!expanding_p && !processing_template_decl && calls_setjmp_p (fndecl))
14438     DECL_UNINLINABLE (fndecl) = 1;
14439
14440   if (expand_p)
14441     {
14442       int returns_null;
14443       int returns_value;
14444
14445       /* So we can tell if jump_optimize sets it to 1.  */
14446       can_reach_end = 0;
14447
14448       /* Before we call rest_of_compilation (which will pop the
14449          CURRENT_FUNCTION), we must save these values.  */
14450       returns_null = current_function_returns_null;
14451       returns_value = current_function_returns_value;
14452
14453       /* If this is a nested function (like a template instantiation
14454          that we're compiling in the midst of compiling something
14455          else), push a new GC context.  That will keep local variables
14456          on the stack from being collected while we're doing the
14457          compilation of this function.  */
14458       if (function_depth > 1)
14459         ggc_push_context ();
14460
14461       /* Run the optimizers and output the assembler code for this
14462          function.  */
14463       rest_of_compilation (fndecl);
14464
14465       /* Undo the call to ggc_push_context above.  */
14466       if (function_depth > 1)
14467         ggc_pop_context ();
14468
14469       if (DECL_SAVED_INSNS (fndecl) && ! TREE_ASM_WRITTEN (fndecl))
14470         {
14471           /* Set DECL_EXTERNAL so that assemble_external will be called as
14472              necessary.  We'll clear it again in finish_file.  */
14473           if (! DECL_EXTERNAL (fndecl))
14474             DECL_NOT_REALLY_EXTERN (fndecl) = 1;
14475           DECL_EXTERNAL (fndecl) = 1;
14476           defer_fn (fndecl);
14477         }
14478
14479 #if 0
14480       /* Keep this code around in case we later want to control debug info
14481          based on whether a type is "used".  (jason 1999-11-11) */
14482
14483       if (ctype && TREE_ASM_WRITTEN (fndecl))
14484         note_debug_info_needed (ctype);
14485 #endif
14486
14487       returns_null |= can_reach_end;
14488
14489       /* Since we don't normally go through c_expand_return for constructors,
14490          this normally gets the wrong value.
14491          Also, named return values have their return codes emitted after
14492          NOTE_INSN_FUNCTION_END, confusing jump.c.  */
14493       if (DECL_CONSTRUCTOR_P (fndecl)
14494           || DECL_NAME (DECL_RESULT (fndecl)) != NULL_TREE)
14495         returns_null = 0;
14496
14497       if (TREE_THIS_VOLATILE (fndecl) && returns_null)
14498         cp_warning ("`noreturn' function `%D' does return", fndecl);
14499       else if ((warn_return_type || pedantic)
14500                && returns_null
14501                && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE)
14502         {
14503           /* If this function returns non-void and control can drop through,
14504              complain.  */
14505           cp_warning ("control reaches end of non-void function `%D'", fndecl);
14506         }
14507       /* With just -W, complain only if function returns both with
14508          and without a value.  */
14509       else if (extra_warnings && returns_value && returns_null)
14510         warning ("this function may return with or without a value");
14511     }
14512   else
14513     {
14514       /* Clear out memory we no longer need.  */
14515       free_after_parsing (cfun);
14516       /* Since we never call rest_of_compilation, we never clear
14517          CFUN.  Do so explicitly.  */
14518       free_after_compilation (cfun);
14519       cfun = NULL;
14520     }
14521
14522   /* If this is a in-class inline definition, we may have to pop the
14523      bindings for the template parameters that we added in
14524      maybe_begin_member_template_processing when start_function was
14525      called.  */
14526   if (inclass_inline)
14527     maybe_end_member_template_processing ();
14528
14529   /* Leave the scope of the class.  */
14530   if (ctype)
14531     pop_nested_class ();
14532
14533   --function_depth;
14534
14535   if (!DECL_SAVED_INSNS (fndecl) && !DECL_SAVED_FUNCTION_DATA (fndecl)
14536       && !(flag_inline_trees && DECL_INLINE (fndecl)))
14537     {
14538       tree t;
14539
14540       /* Stop pointing to the local nodes about to be freed.  */
14541       /* But DECL_INITIAL must remain nonzero so we know this
14542          was an actual function definition.  */
14543       DECL_INITIAL (fndecl) = error_mark_node;
14544       for (t = DECL_ARGUMENTS (fndecl); t; t = TREE_CHAIN (t))
14545         DECL_RTL (t) = DECL_INCOMING_RTL (t) = NULL_RTX;
14546     }
14547
14548   if (DECL_STATIC_CONSTRUCTOR (fndecl))
14549     static_ctors = tree_cons (NULL_TREE, fndecl, static_ctors);
14550   if (DECL_STATIC_DESTRUCTOR (fndecl))
14551     static_dtors = tree_cons (NULL_TREE, fndecl, static_dtors);
14552
14553   /* Clean up.  */
14554   if (! nested)
14555     {
14556       /* Let the error reporting routines know that we're outside a
14557          function.  For a nested function, this value is used in
14558          pop_cp_function_context and then reset via pop_function_context.  */
14559       current_function_decl = NULL_TREE;
14560       /* We don't really care about obstacks, but the middle-end
14561          sometimes cares on what obstck things are located.  */
14562       permanent_allocation (1);
14563     }
14564
14565   return fndecl;
14566 }
14567 \f
14568 /* Create the FUNCTION_DECL for a function definition.
14569    DECLSPECS and DECLARATOR are the parts of the declaration;
14570    they describe the return type and the name of the function,
14571    but twisted together in a fashion that parallels the syntax of C.
14572
14573    This function creates a binding context for the function body
14574    as well as setting up the FUNCTION_DECL in current_function_decl.
14575
14576    Returns a FUNCTION_DECL on success.
14577
14578    If the DECLARATOR is not suitable for a function (it defines a datum
14579    instead), we return 0, which tells yyparse to report a parse error.
14580
14581    May return void_type_node indicating that this method is actually
14582    a friend.  See grokfield for more details.
14583
14584    Came here with a `.pushlevel' .
14585
14586    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14587    CHANGES TO CODE IN `grokfield'.  */
14588
14589 tree
14590 start_method (declspecs, declarator, attrlist)
14591      tree declarator, declspecs, attrlist;
14592 {
14593   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14594                                 attrlist);
14595
14596   /* Something too ugly to handle.  */
14597   if (fndecl == NULL_TREE)
14598     return NULL_TREE;
14599
14600   /* Pass friends other than inline friend functions back.  */
14601   if (fndecl == void_type_node)
14602     return fndecl;
14603
14604   if (TREE_CODE (fndecl) != FUNCTION_DECL)
14605     /* Not a function, tell parser to report parse error.  */
14606     return NULL_TREE;
14607
14608   if (DECL_IN_AGGR_P (fndecl))
14609     {
14610       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14611         {
14612           if (DECL_CONTEXT (fndecl)
14613               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14614             cp_error ("`%D' is already defined in class %s", fndecl,
14615                              TYPE_NAME_STRING (DECL_CONTEXT (fndecl)));
14616         }
14617       return void_type_node;
14618     }
14619
14620   check_template_shadow (fndecl);
14621
14622   DECL_THIS_INLINE (fndecl) = 1;
14623
14624   if (flag_default_inline)
14625     DECL_INLINE (fndecl) = 1;
14626
14627   /* We process method specializations in finish_struct_1.  */
14628   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14629     fndecl = push_template_decl (fndecl);
14630
14631   if (! DECL_FRIEND_P (fndecl))
14632     {
14633       if (TREE_CHAIN (fndecl))
14634         {
14635           fndecl = copy_node (fndecl);
14636           TREE_CHAIN (fndecl) = NULL_TREE;
14637         }
14638
14639       if (DECL_CONSTRUCTOR_P (fndecl))
14640         {
14641           if (! grok_ctor_properties (current_class_type, fndecl))
14642             return void_type_node;
14643         }
14644       else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl)))
14645         grok_op_properties (fndecl, DECL_VIRTUAL_P (fndecl), 0);
14646     }
14647
14648   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14649
14650   /* Make a place for the parms */
14651   pushlevel (0);
14652   current_binding_level->parm_flag = 1;
14653
14654   DECL_IN_AGGR_P (fndecl) = 1;
14655   return fndecl;
14656 }
14657
14658 /* Go through the motions of finishing a function definition.
14659    We don't compile this method until after the whole class has
14660    been processed.
14661
14662    FINISH_METHOD must return something that looks as though it
14663    came from GROKFIELD (since we are defining a method, after all).
14664
14665    This is called after parsing the body of the function definition.
14666    STMTS is the chain of statements that makes up the function body.
14667
14668    DECL is the ..._DECL that `start_method' provided.  */
14669
14670 tree
14671 finish_method (decl)
14672      tree decl;
14673 {
14674   register tree fndecl = decl;
14675   tree old_initial;
14676
14677   register tree link;
14678
14679   if (decl == void_type_node)
14680     return decl;
14681
14682   old_initial = DECL_INITIAL (fndecl);
14683
14684   /* Undo the level for the parms (from start_method).
14685      This is like poplevel, but it causes nothing to be
14686      saved.  Saving information here confuses symbol-table
14687      output routines.  Besides, this information will
14688      be correctly output when this method is actually
14689      compiled.  */
14690
14691   /* Clear out the meanings of the local variables of this level;
14692      also record in each decl which block it belongs to.  */
14693
14694   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14695     {
14696       if (DECL_NAME (link) != NULL_TREE)
14697         pop_binding (DECL_NAME (link), link);
14698       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14699       DECL_CONTEXT (link) = NULL_TREE;
14700     }
14701
14702   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
14703                       (HOST_WIDE_INT) current_binding_level->level_chain,
14704                       current_binding_level->parm_flag,
14705                       current_binding_level->keep);
14706
14707   poplevel (0, 0, 0);
14708
14709   DECL_INITIAL (fndecl) = old_initial;
14710
14711   /* We used to check if the context of FNDECL was different from
14712      current_class_type as another way to get inside here.  This didn't work
14713      for String.cc in libg++.  */
14714   if (DECL_FRIEND_P (fndecl))
14715     {
14716       CLASSTYPE_INLINE_FRIENDS (current_class_type)
14717         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14718       decl = void_type_node;
14719     }
14720
14721   return decl;
14722 }
14723 \f
14724 /* Called when a new struct TYPE is defined.
14725    If this structure or union completes the type of any previous
14726    variable declaration, lay it out and output its rtl.  */
14727
14728 void
14729 hack_incomplete_structures (type)
14730      tree type;
14731 {
14732   tree *list;
14733   struct binding_level *level;
14734
14735   if (!type) /* Don't do this for class templates.  */
14736     return;
14737
14738   if (namespace_bindings_p ())
14739     {
14740       level = 0;
14741       list = &namespace_scope_incomplete;
14742     }
14743   else
14744     {
14745       level = innermost_nonclass_level ();
14746       list = &level->incomplete;
14747     }
14748
14749   while (1)
14750     {
14751       while (*list)
14752         {
14753           tree decl = TREE_VALUE (*list);
14754           if ((decl && TREE_TYPE (decl) == type)
14755               || (TREE_TYPE (decl)
14756                   && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14757                   && TREE_TYPE (TREE_TYPE (decl)) == type))
14758             {
14759               int toplevel = toplevel_bindings_p ();
14760               if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14761                   && TREE_TYPE (TREE_TYPE (decl)) == type)
14762                 layout_type (TREE_TYPE (decl));
14763               layout_decl (decl, 0);
14764               rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
14765               if (! toplevel)
14766                 {
14767                   tree cleanup;
14768                   expand_decl (decl);
14769                   cleanup = maybe_build_cleanup (decl);
14770                   expand_decl_init (decl);
14771                   if (! expand_decl_cleanup (decl, cleanup))
14772                     cp_error ("parser lost in parsing declaration of `%D'",
14773                               decl);
14774                 }
14775               *list = TREE_CHAIN (*list);
14776             }
14777           else
14778             list = &TREE_CHAIN (*list);
14779         }
14780
14781       /* Keep looking through artificial binding levels generated
14782          for local variables.  */
14783       if (level && level->keep == 2)
14784         {
14785           level = level->level_chain;
14786           list = &level->incomplete;
14787         }
14788       else
14789         break;
14790     }
14791 }
14792
14793 /* If DECL is of a type which needs a cleanup, build that cleanup
14794    here.  */
14795
14796 tree
14797 maybe_build_cleanup (decl)
14798      tree decl;
14799 {
14800   tree type = TREE_TYPE (decl);
14801
14802   if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14803     {
14804       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14805       tree rval;
14806
14807       if (TREE_CODE (type) == ARRAY_TYPE)
14808         rval = decl;
14809       else
14810         {
14811           mark_addressable (decl);
14812           rval = build_unary_op (ADDR_EXPR, decl, 0);
14813         }
14814
14815       /* Optimize for space over speed here.  */
14816       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14817           || flag_expensive_optimizations)
14818         flags |= LOOKUP_NONVIRTUAL;
14819
14820       rval = build_delete (TREE_TYPE (rval), rval,
14821                            sfk_complete_destructor, flags, 0);
14822
14823       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14824           && ! TYPE_HAS_DESTRUCTOR (type))
14825         rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14826                                                build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14827
14828       return rval;
14829     }
14830   return 0;
14831 }
14832 \f
14833 /* Expand a C++ expression at the statement level.
14834    This is needed to ferret out nodes which have UNKNOWN_TYPE.
14835    The C++ type checker should get all of these out when
14836    expressions are combined with other, type-providing, expressions,
14837    leaving only orphan expressions, such as:
14838
14839    &class::bar;         / / takes its address, but does nothing with it.  */
14840
14841 void
14842 cplus_expand_expr_stmt (exp)
14843      tree exp;
14844 {
14845 #if 0
14846   /* We should do this eventually, but right now this causes regex.o from
14847      libg++ to miscompile, and tString to core dump.  */
14848   exp = build1 (CLEANUP_POINT_EXPR, TREE_TYPE (exp), exp);
14849 #endif
14850
14851   /* If we don't do this, we end up down inside expand_expr
14852      trying to do TYPE_MODE on the ERROR_MARK, and really
14853      go outside the bounds of the type.  */
14854   if (exp != error_mark_node)
14855     expand_expr_stmt (exp);
14856 }
14857
14858 /* When a stmt has been parsed, this function is called.  */
14859
14860 void
14861 finish_stmt ()
14862 {
14863   /* Always assume this statement was not an expression statement.  If
14864      it actually was an expression statement, its our callers
14865      responsibility to fix this up.  */
14866   last_expr_type = NULL_TREE;
14867 }
14868
14869 /* DECL was originally constructed as a non-static member function,
14870    but turned out to be static.  Update it accordingly.  */
14871
14872 void
14873 revert_static_member_fn (decl)
14874      tree decl;
14875 {
14876   tree tmp;
14877   tree function = TREE_TYPE (decl);
14878   tree args = TYPE_ARG_TYPES (function);
14879
14880   if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args)))
14881       != TYPE_UNQUALIFIED)
14882     cp_error ("static member function `%#D' declared with type qualifiers",
14883               *decl);
14884
14885   args = TREE_CHAIN (args);
14886   tmp = build_function_type (TREE_TYPE (function), args);
14887   tmp = build_qualified_type (tmp, CP_TYPE_QUALS (function));
14888   tmp = build_exception_variant (tmp,
14889                                  TYPE_RAISES_EXCEPTIONS (function));
14890   TREE_TYPE (decl) = tmp;
14891   if (DECL_ARGUMENTS (decl))
14892     DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
14893   DECL_STATIC_FUNCTION_P (decl) = 1;
14894 }
14895
14896 /* Initialize the variables used during compilation of a C++
14897    function.  */
14898
14899 static void
14900 push_cp_function_context (f)
14901      struct function *f;
14902 {
14903   struct language_function *p
14904     = ((struct language_function *)
14905        xcalloc (1, sizeof (struct language_function)));
14906   f->language = p;
14907
14908   /* It takes an explicit call to expand_body to generate RTL for a
14909      function.  */
14910   expanding_p = 0;
14911
14912   /* Whenever we start a new function, we destroy temporaries in the
14913      usual way.  */
14914   current_stmt_tree->stmts_are_full_exprs_p = 1;
14915 }
14916
14917 /* Free the language-specific parts of F, now that we've finished
14918    compiling the function.  */
14919
14920 static void
14921 pop_cp_function_context (f)
14922      struct function *f;
14923 {
14924   if (f->language)
14925     free (f->language);
14926   f->language = 0;
14927 }
14928
14929 /* Mark P for GC.  */
14930
14931 static void
14932 mark_lang_function (p)
14933      struct language_function *p;
14934 {
14935   if (!p)
14936     return;
14937
14938   ggc_mark_tree (p->x_ctor_label);
14939   ggc_mark_tree (p->x_dtor_label);
14940   ggc_mark_tree (p->x_current_class_ptr);
14941   ggc_mark_tree (p->x_current_class_ref);
14942   ggc_mark_tree (p->x_eh_spec_try_block);
14943   ggc_mark_tree (p->x_scope_stmt_stack);
14944
14945   ggc_mark_rtx (p->x_result_rtx);
14946
14947   mark_named_label_lists (&p->x_named_labels, &p->x_named_label_uses);
14948   mark_stmt_tree (&p->x_stmt_tree);
14949   mark_binding_level (&p->bindings);
14950 }
14951
14952 /* Mark the language-specific data in F for GC.  */
14953
14954 static void
14955 mark_cp_function_context (f)
14956      struct function *f;
14957 {
14958   mark_lang_function (f->language);
14959 }
14960
14961 void
14962 lang_mark_false_label_stack (l)
14963      struct label_node *l;
14964 {
14965   /* C++ doesn't use false_label_stack.  It better be NULL.  */
14966   my_friendly_assert (l == NULL, 19990904);
14967 }
14968
14969 void
14970 lang_mark_tree (t)
14971      tree t;
14972 {
14973   enum tree_code code = TREE_CODE (t);
14974   if (code == IDENTIFIER_NODE)
14975     {
14976       struct lang_identifier *li = (struct lang_identifier *) t;
14977       struct lang_id2 *li2 = li->x;
14978       ggc_mark_tree (li->namespace_bindings);
14979       ggc_mark_tree (li->bindings);
14980       ggc_mark_tree (li->class_value);
14981       ggc_mark_tree (li->class_template_info);
14982
14983       if (li2)
14984         {
14985           ggc_mark_tree (li2->label_value);
14986           ggc_mark_tree (li2->implicit_decl);
14987           ggc_mark_tree (li2->error_locus);
14988         }
14989     }
14990   else if (code == CPLUS_BINDING)
14991     {
14992       if (BINDING_HAS_LEVEL_P (t))
14993         mark_binding_level (&BINDING_LEVEL (t));
14994       else
14995         ggc_mark_tree (BINDING_SCOPE (t));
14996       ggc_mark_tree (BINDING_VALUE (t));
14997     }
14998   else if (code == OVERLOAD)
14999     ggc_mark_tree (OVL_FUNCTION (t));
15000   else if (code == TEMPLATE_PARM_INDEX)
15001     ggc_mark_tree (TEMPLATE_PARM_DECL (t));
15002   else if (TREE_CODE_CLASS (code) == 'd')
15003     {
15004       struct lang_decl *ld = DECL_LANG_SPECIFIC (t);
15005
15006       if (ld)
15007         {
15008           ggc_mark (ld);
15009           if (!DECL_GLOBAL_CTOR_P (t)
15010               && !DECL_GLOBAL_DTOR_P (t)
15011               && !DECL_THUNK_P (t))
15012             ggc_mark_tree (ld->decl_flags.u2.access);
15013           else if (DECL_THUNK_P (t))
15014             ggc_mark_tree (ld->decl_flags.u2.vcall_offset);
15015           ggc_mark_tree (ld->decl_flags.context);
15016           if (TREE_CODE (t) != NAMESPACE_DECL)
15017             ggc_mark_tree (ld->decl_flags.u.template_info);
15018           else
15019             mark_binding_level (&NAMESPACE_LEVEL (t));
15020           if (CAN_HAVE_FULL_LANG_DECL_P (t))
15021             {
15022               ggc_mark_tree (ld->befriending_classes);
15023               ggc_mark_tree (ld->saved_tree);
15024               ggc_mark_tree (ld->cloned_function);
15025               if (!DECL_OVERLOADED_OPERATOR_P (t))
15026                 ggc_mark_tree (ld->u2.vtt_parm);
15027               if (TREE_CODE (t) == TYPE_DECL)
15028                 ggc_mark_tree (ld->u.sorted_fields);
15029               else if (TREE_CODE (t) == FUNCTION_DECL
15030                        && !DECL_PENDING_INLINE_P (t))
15031                 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t));
15032             }
15033         }
15034     }
15035   else if (TREE_CODE_CLASS (code) == 't')
15036     {
15037       struct lang_type *lt = TYPE_LANG_SPECIFIC (t);
15038
15039       if (lt && !(TREE_CODE (t) == POINTER_TYPE
15040                   && TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE))
15041         {
15042           ggc_mark (lt);
15043           ggc_mark_tree (lt->vfields);
15044           ggc_mark_tree (lt->vbases);
15045           ggc_mark_tree (lt->tags);
15046           ggc_mark_tree (lt->size);
15047           ggc_mark_tree (lt->pure_virtuals);
15048           ggc_mark_tree (lt->friend_classes);
15049           ggc_mark_tree (lt->rtti);
15050           ggc_mark_tree (lt->methods);
15051           ggc_mark_tree (lt->template_info);
15052           ggc_mark_tree (lt->befriending_classes);
15053         }
15054       else if (lt)
15055         /* In the case of pointer-to-member function types, the
15056            TYPE_LANG_SPECIFIC is really just a tree.  */
15057         ggc_mark_tree ((tree) lt);
15058     }
15059 }