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   else
1036     {
1037       cp_error ("declaration of `%#D'", decl);
1038       cp_error_at ("conflicts with previous declaration `%#D'",
1039                    BINDING_VALUE (binding));
1040       ok = 0;
1041     }
1042
1043   return ok;
1044 }
1045
1046 /* Add DECL to the list of things declared in B.  */
1047
1048 static void
1049 add_decl_to_level (decl, b)
1050      tree decl;
1051      struct binding_level *b;
1052 {
1053   /* We build up the list in reverse order, and reverse it later if
1054      necessary.  */
1055   TREE_CHAIN (decl) = b->names;
1056   b->names = decl;
1057 }
1058
1059 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1060    binding level.  If PUSH_USING is set in FLAGS, we know that DECL
1061    doesn't really belong to this binding level, that it got here
1062    through a using-declaration.  */
1063
1064 void
1065 push_local_binding (id, decl, flags)
1066      tree id;
1067      tree decl;
1068      int flags;
1069 {
1070   struct binding_level *b;
1071
1072   /* Skip over any local classes.  This makes sense if we call
1073      push_local_binding with a friend decl of a local class.  */
1074   b = current_binding_level;
1075   while (b->parm_flag == 2)
1076     b = b->level_chain;
1077
1078   if (lookup_name_current_level (id))
1079     {
1080       /* Supplement the existing binding.  */
1081       if (!add_binding (id, decl))
1082         /* It didn't work.  Something else must be bound at this
1083            level.  Do not add DECL to the list of things to pop
1084            later.  */
1085         return;
1086     }
1087   else
1088     /* Create a new binding.  */
1089     push_binding (id, decl, b);
1090
1091   if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1092     /* We must put the OVERLOAD into a TREE_LIST since the
1093        TREE_CHAIN of an OVERLOAD is already used.  Similarly for
1094        decls that got here through a using-declaration.  */
1095     decl = build_tree_list (NULL_TREE, decl);
1096
1097   /* And put DECL on the list of things declared by the current
1098      binding level.  */
1099   add_decl_to_level (decl, b);
1100 }
1101
1102 /* Bind DECL to ID in the class_binding_level.  Returns nonzero if the
1103    binding was successful.  */
1104
1105 int
1106 push_class_binding (id, decl)
1107      tree id;
1108      tree decl;
1109 {
1110   int result = 1;
1111   tree binding = IDENTIFIER_BINDING (id);
1112   tree context;
1113
1114   /* Note that we declared this value so that we can issue an error if
1115      this an illegal redeclaration of a name already used for some
1116      other purpose.  */
1117   note_name_declared_in_class (id, decl);
1118
1119   if (binding && BINDING_LEVEL (binding) == class_binding_level)
1120     /* Supplement the existing binding.  */
1121     result = add_binding (id, decl);
1122   else
1123     /* Create a new binding.  */
1124     push_binding (id, decl, class_binding_level);
1125
1126   /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1127      class-level declaration.  Note that we do not use DECL here
1128      because of the possibility of the `struct stat' hack; if DECL is
1129      a class-name or enum-name we might prefer a field-name, or some
1130      such.  */
1131   IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
1132
1133   /* If this is a binding from a base class, mark it as such.  */
1134   binding = IDENTIFIER_BINDING (id);
1135   if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
1136     {
1137       /* Any implicit typename must be from a base-class.  The
1138          context for an implicit typename declaration is always
1139          the derived class in which the lookup was done, so the checks
1140          based on the context of DECL below will not trigger.  */
1141       if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl))
1142         INHERITED_VALUE_BINDING_P (binding) = 1;
1143       else
1144         {
1145           if (TREE_CODE (decl) == OVERLOAD)
1146             context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
1147           else
1148             {
1149               my_friendly_assert (DECL_P (decl), 0);
1150               context = CP_DECL_CONTEXT (decl);
1151             }
1152
1153           if (is_properly_derived_from (current_class_type, context))
1154             INHERITED_VALUE_BINDING_P (binding) = 1;
1155           else
1156             INHERITED_VALUE_BINDING_P (binding) = 0;
1157         }
1158     }
1159   else if (BINDING_VALUE (binding) == decl)
1160     /* We only encounter a TREE_LIST when push_class_decls detects an
1161        ambiguity.  Such an ambiguity can be overridden by a definition
1162        in this class.  */
1163     INHERITED_VALUE_BINDING_P (binding) = 1;
1164
1165   return result;
1166 }
1167
1168 /* Remove the binding for DECL which should be the innermost binding
1169    for ID.  */
1170
1171 static void
1172 pop_binding (id, decl)
1173      tree id;
1174      tree decl;
1175 {
1176   tree binding;
1177
1178   if (id == NULL_TREE)
1179     /* It's easiest to write the loops that call this function without
1180        checking whether or not the entities involved have names.  We
1181        get here for such an entity.  */
1182     return;
1183
1184   /* Get the innermost binding for ID.  */
1185   binding = IDENTIFIER_BINDING (id);
1186
1187   /* The name should be bound.  */
1188   my_friendly_assert (binding != NULL_TREE, 0);
1189
1190   /* The DECL will be either the ordinary binding or the type
1191      binding for this identifier.  Remove that binding.  */
1192   if (BINDING_VALUE (binding) == decl)
1193     BINDING_VALUE (binding) = NULL_TREE;
1194   else if (BINDING_TYPE (binding) == decl)
1195     BINDING_TYPE (binding) = NULL_TREE;
1196   else
1197     my_friendly_abort (0);
1198
1199   if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
1200     /* We're completely done with the innermost binding for this
1201        identifier.  Unhook it from the list of bindings.  */
1202     IDENTIFIER_BINDING (id) = TREE_CHAIN (binding);
1203 }
1204
1205 /* When a label goes out of scope, check to see if that label was used
1206    in a valid manner, and issue any appropriate warnings or errors.  */
1207
1208 static void
1209 pop_label (label, old_value)
1210      tree label;
1211      tree old_value;
1212 {
1213   if (!processing_template_decl && doing_semantic_analysis_p ())
1214     {
1215       if (DECL_INITIAL (label) == NULL_TREE)
1216         {
1217           cp_error_at ("label `%D' used but not defined", label);
1218           /* Avoid crashing later.  */
1219           define_label (input_filename, 1, DECL_NAME (label));
1220         }
1221       else if (warn_unused_label && !TREE_USED (label))
1222         cp_warning_at ("label `%D' defined but not used", label);
1223     }
1224
1225   SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
1226 }
1227
1228 /* At the end of a function, all labels declared within the fucntion
1229    go out of scope.  BLOCK is the top-level block for the
1230    function.  */
1231
1232 static void
1233 pop_labels (block)
1234      tree block;
1235 {
1236   struct named_label_list *link;
1237
1238   /* Clear out the definitions of all label names, since their scopes
1239      end here.  */
1240   for (link = named_labels; link; link = link->next)
1241     {
1242       pop_label (link->label_decl, link->old_value);
1243       /* Put the labels into the "variables" of the top-level block,
1244          so debugger can see them.  */
1245       TREE_CHAIN (link->label_decl) = BLOCK_VARS (block);
1246       BLOCK_VARS (block) = link->label_decl;
1247     }
1248
1249   named_labels = NULL;
1250 }
1251
1252 /* Exit a binding level.
1253    Pop the level off, and restore the state of the identifier-decl mappings
1254    that were in effect when this level was entered.
1255
1256    If KEEP == 1, this level had explicit declarations, so
1257    and create a "block" (a BLOCK node) for the level
1258    to record its declarations and subblocks for symbol table output.
1259
1260    If FUNCTIONBODY is nonzero, this level is the body of a function,
1261    so create a block as if KEEP were set and also clear out all
1262    label names.
1263
1264    If REVERSE is nonzero, reverse the order of decls before putting
1265    them into the BLOCK.  */
1266
1267 tree
1268 poplevel (keep, reverse, functionbody)
1269      int keep;
1270      int reverse;
1271      int functionbody;
1272 {
1273   register tree link;
1274   /* The chain of decls was accumulated in reverse order.
1275      Put it into forward order, just for cleanliness.  */
1276   tree decls;
1277   int tmp = functionbody;
1278   int real_functionbody;
1279   tree tags;
1280   tree subblocks;
1281   tree block = NULL_TREE;
1282   tree decl;
1283   int block_previously_created;
1284   int leaving_for_scope;
1285
1286   if (cfun && !doing_semantic_analysis_p ())
1287     return NULL_TREE;
1288
1289   my_friendly_assert (current_binding_level->parm_flag != 2,
1290                       19990916);
1291
1292   real_functionbody = (current_binding_level->keep == 2
1293                        ? ((functionbody = 0), tmp) : functionbody);
1294   tags = functionbody >= 0 ? current_binding_level->tags : 0;
1295   subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1296
1297   my_friendly_assert (!current_binding_level->class_shadowed,
1298                       19990414);
1299
1300   /* We used to use KEEP == 2 to indicate that the new block should go
1301      at the beginning of the list of blocks at this binding level,
1302      rather than the end.  This hack is no longer used.  */
1303   my_friendly_assert (keep == 0 || keep == 1, 0);
1304
1305   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
1306                       (HOST_WIDE_INT) current_binding_level->level_chain,
1307                       current_binding_level->parm_flag,
1308                       current_binding_level->keep);
1309
1310   if (current_binding_level->keep == 1)
1311     keep = 1;
1312
1313   /* Any uses of undefined labels, and any defined labels, now operate
1314      under constraints of next binding contour.  */
1315   if (cfun && !functionbody)
1316     {
1317       struct binding_level *level_chain;
1318       level_chain = current_binding_level->level_chain;
1319       if (level_chain)
1320         {
1321           struct named_label_use_list *uses;
1322           struct named_label_list *labels;
1323           for (labels = named_labels; labels; labels = labels->next)
1324             if (labels->binding_level == current_binding_level)
1325               {
1326                 tree decl;
1327                 if (current_binding_level->eh_region)
1328                   labels->eh_region = 1;
1329                 for (decl = labels->names_in_scope; decl;
1330                      decl = TREE_CHAIN (decl))
1331                   if (decl_jump_unsafe (decl))
1332                     labels->bad_decls = tree_cons (NULL_TREE, decl,
1333                                                    labels->bad_decls);
1334                 labels->binding_level = level_chain;
1335                 labels->names_in_scope = level_chain->names;
1336               }
1337
1338           for (uses = named_label_uses; uses; uses = uses->next)
1339             if (uses->binding_level == current_binding_level)
1340               {
1341                 uses->binding_level = level_chain;
1342                 uses->names_in_scope = level_chain->names;
1343               }
1344         }
1345     }
1346
1347   /* Get the decls in the order they were written.
1348      Usually current_binding_level->names is in reverse order.
1349      But parameter decls were previously put in forward order.  */
1350
1351   if (reverse)
1352     current_binding_level->names
1353       = decls = nreverse (current_binding_level->names);
1354   else
1355     decls = current_binding_level->names;
1356
1357   /* Output any nested inline functions within this block
1358      if they weren't already output.  */
1359   for (decl = decls; decl; decl = TREE_CHAIN (decl))
1360     if (TREE_CODE (decl) == FUNCTION_DECL
1361         && ! TREE_ASM_WRITTEN (decl)
1362         && DECL_INITIAL (decl) != NULL_TREE
1363         && TREE_ADDRESSABLE (decl)
1364         && decl_function_context (decl) == current_function_decl)
1365       {
1366         /* If this decl was copied from a file-scope decl
1367            on account of a block-scope extern decl,
1368            propagate TREE_ADDRESSABLE to the file-scope decl.  */
1369         if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1370           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1371         else
1372           {
1373             push_function_context ();
1374             output_inline_function (decl);
1375             pop_function_context ();
1376           }
1377       }
1378
1379   /* When not in function-at-a-time mode, expand_end_bindings will
1380      warn about unused variables.  But, in function-at-a-time mode
1381      expand_end_bindings is not passed the list of variables in the
1382      current scope, and therefore no warning is emitted.  So, we
1383      explicitly warn here.  */
1384   if (!processing_template_decl)
1385     warn_about_unused_variables (getdecls ());
1386
1387   /* If there were any declarations or structure tags in that level,
1388      or if this level is a function body,
1389      create a BLOCK to record them for the life of this function.  */
1390   block = NULL_TREE;
1391   block_previously_created = (current_binding_level->this_block != NULL_TREE);
1392   if (block_previously_created)
1393     block = current_binding_level->this_block;
1394   else if (keep == 1 || functionbody)
1395     block = make_node (BLOCK);
1396   if (block != NULL_TREE)
1397     {
1398       if (block_previously_created)
1399         {
1400           if (decls || tags || subblocks)
1401             {
1402               if (BLOCK_VARS (block))
1403                 warning ("internal compiler error: debugging info corrupted");
1404
1405               BLOCK_VARS (block) = decls;
1406
1407               /* We can have previous subblocks and new subblocks when
1408                  doing fixup_gotos with complex cleanups.  We chain the new
1409                  subblocks onto the end of any pre-existing subblocks.  */
1410               BLOCK_SUBBLOCKS (block) = chainon (BLOCK_SUBBLOCKS (block),
1411                                                  subblocks);
1412             }
1413         }
1414       else
1415         {
1416           BLOCK_VARS (block) = decls;
1417           BLOCK_SUBBLOCKS (block) = subblocks;
1418         }
1419     }
1420
1421   /* In each subblock, record that this is its superior.  */
1422   if (keep >= 0)
1423     for (link = subblocks; link; link = TREE_CHAIN (link))
1424       BLOCK_SUPERCONTEXT (link) = block;
1425
1426   /* We still support the old for-scope rules, whereby the variables
1427      in a for-init statement were in scope after the for-statement
1428      ended.  We only use the new rules in flag_new_for_scope is
1429      nonzero.  */
1430   leaving_for_scope
1431     = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1432
1433   /* Remove declarations for all the DECLs in this level.  */
1434   for (link = decls; link; link = TREE_CHAIN (link))
1435     {
1436       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL)
1437         {
1438           tree outer_binding
1439             = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1440           tree ns_binding;
1441
1442           if (!outer_binding)
1443             ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1444           else
1445             ns_binding = NULL_TREE;
1446
1447           if (outer_binding
1448               && (BINDING_LEVEL (outer_binding)
1449                   == current_binding_level->level_chain))
1450             /* We have something like:
1451
1452                  int i;
1453                  for (int i; ;);
1454
1455                and we are leaving the `for' scope.  There's no reason to
1456                keep the binding of the inner `i' in this case.  */
1457             pop_binding (DECL_NAME (link), link);
1458           else if ((outer_binding
1459                     && (TREE_CODE (BINDING_VALUE (outer_binding))
1460                         == TYPE_DECL))
1461                    || (ns_binding
1462                        && TREE_CODE (ns_binding) == TYPE_DECL))
1463             /* Here, we have something like:
1464
1465                  typedef int I;
1466
1467                  void f () {
1468                    for (int I; ;);
1469                  }
1470
1471                We must pop the for-scope binding so we know what's a
1472                type and what isn't.  */
1473             pop_binding (DECL_NAME (link), link);
1474           else
1475             {
1476               /* Mark this VAR_DECL as dead so that we can tell we left it
1477                  there only for backward compatibility.  */
1478               DECL_DEAD_FOR_LOCAL (link) = 1;
1479
1480               /* Keep track of what should of have happenned when we
1481                  popped the binding.  */
1482               if (outer_binding && BINDING_VALUE (outer_binding))
1483                 DECL_SHADOWED_FOR_VAR (link)
1484                   = BINDING_VALUE (outer_binding);
1485
1486               /* Add it to the list of dead variables in the next
1487                  outermost binding to that we can remove these when we
1488                  leave that binding.  */
1489               current_binding_level->level_chain->dead_vars_from_for
1490                 = tree_cons (NULL_TREE, link,
1491                              current_binding_level->level_chain->
1492                              dead_vars_from_for);
1493
1494               /* Although we don't pop the CPLUS_BINDING, we do clear
1495                  its BINDING_LEVEL since the level is going away now.  */
1496               BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1497                 = 0;
1498             }
1499         }
1500       else
1501         {
1502           /* Remove the binding.  */
1503           decl = link;
1504           if (TREE_CODE (decl) == TREE_LIST)
1505             decl = TREE_VALUE (decl);
1506           if (DECL_P (decl))
1507             pop_binding (DECL_NAME (decl), decl);
1508           else if (TREE_CODE (decl) == OVERLOAD)
1509             pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1510           else
1511             my_friendly_abort (0);
1512         }
1513     }
1514
1515   /* Remove declarations for any `for' variables from inner scopes
1516      that we kept around.  */
1517   for (link = current_binding_level->dead_vars_from_for;
1518        link; link = TREE_CHAIN (link))
1519     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1520
1521   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
1522   for (link = current_binding_level->type_shadowed;
1523        link; link = TREE_CHAIN (link))
1524     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1525
1526   /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
1527   for (link = current_binding_level->shadowed_labels;
1528        link;
1529        link = TREE_CHAIN (link))
1530     pop_label (TREE_VALUE (link), TREE_PURPOSE (link));
1531
1532   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1533      list if a `using' declaration put them there.  The debugging
1534      back-ends won't understand OVERLOAD, so we remove them here.
1535      Because the BLOCK_VARS are (temporarily) shared with
1536      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1537      popped all the bindings.  */
1538   if (block)
1539     {
1540       tree* d;
1541
1542       for (d = &BLOCK_VARS (block); *d; )
1543         {
1544           if (TREE_CODE (*d) == TREE_LIST)
1545             *d = TREE_CHAIN (*d);
1546           else
1547             d = &TREE_CHAIN (*d);
1548         }
1549     }
1550
1551   /* If the level being exited is the top level of a function,
1552      check over all the labels.  */
1553   if (functionbody)
1554     {
1555       /* Since this is the top level block of a function, the vars are
1556          the function's parameters.  Don't leave them in the BLOCK
1557          because they are found in the FUNCTION_DECL instead.  */
1558       BLOCK_VARS (block) = 0;
1559       pop_labels (block);
1560     }
1561
1562   tmp = current_binding_level->keep;
1563
1564   pop_binding_level ();
1565   if (functionbody)
1566     DECL_INITIAL (current_function_decl) = block;
1567   else if (block)
1568     {
1569       if (!block_previously_created)
1570         current_binding_level->blocks
1571           = chainon (current_binding_level->blocks, block);
1572     }
1573   /* If we did not make a block for the level just exited,
1574      any blocks made for inner levels
1575      (since they cannot be recorded as subblocks in that level)
1576      must be carried forward so they will later become subblocks
1577      of something else.  */
1578   else if (subblocks)
1579     current_binding_level->blocks
1580       = chainon (current_binding_level->blocks, subblocks);
1581
1582   /* Each and every BLOCK node created here in `poplevel' is important
1583      (e.g. for proper debugging information) so if we created one
1584      earlier, mark it as "used".  */
1585   if (block)
1586     TREE_USED (block) = 1;
1587
1588   /* Take care of compiler's internal binding structures.  */
1589   if (tmp == 2)
1590     {
1591       tree scope_stmts;
1592
1593       scope_stmts
1594         = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1595       if (block)
1596         {
1597           SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1598           SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1599         }
1600
1601       block = poplevel (keep, reverse, functionbody);
1602     }
1603
1604   return block;
1605 }
1606
1607 /* Delete the node BLOCK from the current binding level.
1608    This is used for the block inside a stmt expr ({...})
1609    so that the block can be reinserted where appropriate.  */
1610
1611 void
1612 delete_block (block)
1613      tree block;
1614 {
1615   tree t;
1616   if (current_binding_level->blocks == block)
1617     current_binding_level->blocks = TREE_CHAIN (block);
1618   for (t = current_binding_level->blocks; t;)
1619     {
1620       if (TREE_CHAIN (t) == block)
1621         TREE_CHAIN (t) = TREE_CHAIN (block);
1622       else
1623         t = TREE_CHAIN (t);
1624     }
1625   TREE_CHAIN (block) = NULL_TREE;
1626   /* Clear TREE_USED which is always set by poplevel.
1627      The flag is set again if insert_block is called.  */
1628   TREE_USED (block) = 0;
1629 }
1630
1631 /* Insert BLOCK at the end of the list of subblocks of the
1632    current binding level.  This is used when a BIND_EXPR is expanded,
1633    to handle the BLOCK node inside the BIND_EXPR.  */
1634
1635 void
1636 insert_block (block)
1637      tree block;
1638 {
1639   TREE_USED (block) = 1;
1640   current_binding_level->blocks
1641     = chainon (current_binding_level->blocks, block);
1642 }
1643
1644 /* Set the BLOCK node for the innermost scope
1645    (the one we are currently in).  */
1646
1647 void
1648 set_block (block)
1649     register tree block;
1650 {
1651   current_binding_level->this_block = block;
1652 }
1653
1654 /* Do a pushlevel for class declarations.  */
1655
1656 void
1657 pushlevel_class ()
1658 {
1659   register struct binding_level *newlevel;
1660
1661   /* Reuse or create a struct for this binding level.  */
1662 #if defined(DEBUG_CP_BINDING_LEVELS)
1663   if (0)
1664 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1665   if (free_binding_level)
1666 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1667     {
1668       newlevel = free_binding_level;
1669       free_binding_level = free_binding_level->level_chain;
1670     }
1671   else
1672     newlevel = make_binding_level ();
1673
1674 #if defined(DEBUG_CP_BINDING_LEVELS)
1675   is_class_level = 1;
1676 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1677
1678   push_binding_level (newlevel, 0, 0);
1679
1680   class_binding_level = current_binding_level;
1681   class_binding_level->parm_flag = 2;
1682   class_binding_level->this_class = current_class_type;
1683 }
1684
1685 /* ...and a poplevel for class declarations.  */
1686
1687 void
1688 poplevel_class ()
1689 {
1690   register struct binding_level *level = class_binding_level;
1691   tree shadowed;
1692
1693   my_friendly_assert (level != 0, 354);
1694
1695   /* If we're leaving a toplevel class, don't bother to do the setting
1696      of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1697      shouldn't even be used when current_class_type isn't set, and second,
1698      if we don't touch it here, we're able to use the cache effect if the
1699      next time we're entering a class scope, it is the same class.  */
1700   if (current_class_depth != 1)
1701     {
1702       struct binding_level* b;
1703
1704       /* Clear out our IDENTIFIER_CLASS_VALUEs.  */
1705       for (shadowed = level->class_shadowed;
1706            shadowed;
1707            shadowed = TREE_CHAIN (shadowed))
1708         IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1709
1710       /* Find the next enclosing class, and recreate
1711          IDENTIFIER_CLASS_VALUEs appropriate for that class.  */
1712       b = level->level_chain;
1713       while (b && b->parm_flag != 2)
1714         b = b->level_chain;
1715
1716       if (b)
1717         for (shadowed = b->class_shadowed;
1718              shadowed;
1719              shadowed = TREE_CHAIN (shadowed))
1720           {
1721             tree t;
1722
1723             t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1724             while (t && BINDING_LEVEL (t) != b)
1725               t = TREE_CHAIN (t);
1726
1727             if (t)
1728               IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1729                 = BINDING_VALUE (t);
1730           }
1731     }
1732   else
1733     /* Remember to save what IDENTIFIER's were bound in this scope so we
1734        can recover from cache misses.  */
1735     {
1736       previous_class_type = current_class_type;
1737       previous_class_values = class_binding_level->class_shadowed;
1738     }
1739   for (shadowed = level->type_shadowed;
1740        shadowed;
1741        shadowed = TREE_CHAIN (shadowed))
1742     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1743
1744   /* Remove the bindings for all of the class-level declarations.  */
1745   for (shadowed = level->class_shadowed;
1746        shadowed;
1747        shadowed = TREE_CHAIN (shadowed))
1748     pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1749
1750   GNU_xref_end_scope ((HOST_WIDE_INT) class_binding_level,
1751                       (HOST_WIDE_INT) class_binding_level->level_chain,
1752                       class_binding_level->parm_flag,
1753                       class_binding_level->keep);
1754
1755   /* Now, pop out of the binding level which we created up in the
1756      `pushlevel_class' routine.  */
1757 #if defined(DEBUG_CP_BINDING_LEVELS)
1758   is_class_level = 1;
1759 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1760
1761   pop_binding_level ();
1762 }
1763
1764 /* We are entering the scope of a class.  Clear IDENTIFIER_CLASS_VALUE
1765    for any names in enclosing classes.  */
1766
1767 void
1768 clear_identifier_class_values ()
1769 {
1770   tree t;
1771
1772   if (!class_binding_level)
1773     return;
1774
1775   for (t = class_binding_level->class_shadowed;
1776        t;
1777        t = TREE_CHAIN (t))
1778     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1779 }
1780
1781 /* Returns non-zero if T is a virtual function table.  */
1782
1783 int
1784 vtable_decl_p (t, data)
1785      tree t;
1786      void *data ATTRIBUTE_UNUSED;
1787 {
1788   return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1789 }
1790
1791 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1792    functions.  */
1793
1794 int
1795 vtype_decl_p (t, data)
1796      tree t;
1797      void *data ATTRIBUTE_UNUSED;
1798 {
1799   return (TREE_CODE (t) == TYPE_DECL
1800           && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE
1801           && TYPE_POLYMORPHIC_P (TREE_TYPE (t)));
1802 }
1803
1804 /* Return the declarations that are members of the namespace NS.  */
1805
1806 tree
1807 cp_namespace_decls (ns)
1808      tree ns;
1809 {
1810   return NAMESPACE_LEVEL (ns)->names;
1811 }
1812
1813 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1814    itself, calling F for each.  The DATA is passed to F as well.  */
1815
1816 static int
1817 walk_namespaces_r (namespace, f, data)
1818      tree namespace;
1819      walk_namespaces_fn f;
1820      void *data;
1821 {
1822   tree current;
1823   int result = 0;
1824
1825   result |= (*f) (namespace, data);
1826
1827   for (current = cp_namespace_decls (namespace);
1828        current;
1829        current = TREE_CHAIN (current))
1830     {
1831       if (TREE_CODE (current) != NAMESPACE_DECL
1832           || DECL_NAMESPACE_ALIAS (current))
1833         continue;
1834       if (!DECL_LANG_SPECIFIC (current))
1835         {
1836           /* Hmm. std. */
1837           my_friendly_assert (current == std_node, 393);
1838           continue;
1839         }
1840
1841       /* We found a namespace.  */
1842       result |= walk_namespaces_r (current, f, data);
1843     }
1844
1845   return result;
1846 }
1847
1848 /* Walk all the namespaces, calling F for each.  The DATA is passed to
1849    F as well.  */
1850
1851 int
1852 walk_namespaces (f, data)
1853      walk_namespaces_fn f;
1854      void *data;
1855 {
1856   return walk_namespaces_r (global_namespace, f, data);
1857 }
1858
1859 struct walk_globals_data {
1860   walk_globals_pred p;
1861   walk_globals_fn f;
1862   void *data;
1863 };
1864
1865 /* Walk the global declarations in NAMESPACE.  Whenever one is found
1866    for which P returns non-zero, call F with its address.  If any call
1867    to F returns a non-zero value, return a non-zero value.  */
1868
1869 static int
1870 walk_globals_r (namespace, data)
1871      tree namespace;
1872      void *data;
1873 {
1874   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1875   walk_globals_pred p = wgd->p;
1876   walk_globals_fn f = wgd->f;
1877   void *d = wgd->data;
1878   tree *t;
1879   int result = 0;
1880
1881   t = &NAMESPACE_LEVEL (namespace)->names;
1882
1883   while (*t)
1884     {
1885       tree glbl = *t;
1886
1887       if ((*p) (glbl, d))
1888         result |= (*f) (t, d);
1889
1890       /* If F changed *T, then *T still points at the next item to
1891          examine.  */
1892       if (*t == glbl)
1893         t = &TREE_CHAIN (*t);
1894     }
1895
1896   return result;
1897 }
1898
1899 /* Walk the global declarations.  Whenever one is found for which P
1900    returns non-zero, call F with its address.  If any call to F
1901    returns a non-zero value, return a non-zero value.  */
1902
1903 int
1904 walk_globals (p, f, data)
1905      walk_globals_pred p;
1906      walk_globals_fn f;
1907      void *data;
1908 {
1909   struct walk_globals_data wgd;
1910   wgd.p = p;
1911   wgd.f = f;
1912   wgd.data = data;
1913
1914   return walk_namespaces (walk_globals_r, &wgd);
1915 }
1916
1917 /* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
1918    DATA is non-NULL, this is the last time we will call
1919    wrapup_global_declarations for this NAMESPACE.  */
1920
1921 int
1922 wrapup_globals_for_namespace (namespace, data)
1923      tree namespace;
1924      void *data;
1925 {
1926   tree globals = cp_namespace_decls (namespace);
1927   int len = list_length (globals);
1928   tree *vec = (tree *) alloca (sizeof (tree) * len);
1929   int i;
1930   int result;
1931   tree decl;
1932   int last_time = (data != 0);
1933
1934   if (last_time && namespace == global_namespace)
1935     /* Let compile_file handle the global namespace.  */
1936     return 0;
1937
1938   /* Process the decls in reverse order--earliest first.
1939      Put them into VEC from back to front, then take out from front.  */
1940
1941   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1942     {
1943       /* Pretend we've output an unused static variable.  This ensures
1944          that the toplevel __FUNCTION__ etc won't be emitted, unless
1945          needed. */
1946       if (TREE_CODE (decl) == VAR_DECL && DECL_ARTIFICIAL (decl)
1947           && !TREE_PUBLIC (decl) && !TREE_USED (decl))
1948         {
1949           TREE_ASM_WRITTEN (decl) = 1;
1950           DECL_IGNORED_P (decl) = 1;
1951         }
1952       vec[len - i - 1] = decl;
1953     }
1954
1955   if (last_time)
1956     {
1957       check_global_declarations (vec, len);
1958       return 0;
1959     }
1960
1961   /* Temporarily mark vtables as external.  That prevents
1962      wrapup_global_declarations from writing them out; we must process
1963      them ourselves in finish_vtable_vardecl.  */
1964   for (i = 0; i < len; ++i)
1965     if (vtable_decl_p (vec[i], /*data=*/0) && !DECL_EXTERNAL (vec[i]))
1966       {
1967         DECL_NOT_REALLY_EXTERN (vec[i]) = 1;
1968         DECL_EXTERNAL (vec[i]) = 1;
1969       }
1970
1971   /* Write out any globals that need to be output.  */
1972   result = wrapup_global_declarations (vec, len);
1973
1974   /* Undo the hack to DECL_EXTERNAL above.  */
1975   for (i = 0; i < len; ++i)
1976     if (vtable_decl_p (vec[i], /*data=*/0)
1977         && DECL_NOT_REALLY_EXTERN (vec[i]))
1978       {
1979         DECL_NOT_REALLY_EXTERN (vec[i]) = 0;
1980         DECL_EXTERNAL (vec[i]) = 0;
1981       }
1982
1983   return result;
1984 }
1985
1986 \f
1987 /* Mark ARG (which is really a struct binding_level **) for GC.  */
1988
1989 static void
1990 mark_binding_level (arg)
1991      void *arg;
1992 {
1993   struct binding_level *lvl = *(struct binding_level **)arg;
1994
1995   for (; lvl; lvl = lvl->level_chain)
1996     {
1997       ggc_mark_tree (lvl->names);
1998       ggc_mark_tree (lvl->tags);
1999       ggc_mark_tree (lvl->usings);
2000       ggc_mark_tree (lvl->using_directives);
2001       ggc_mark_tree (lvl->class_shadowed);
2002       ggc_mark_tree (lvl->type_shadowed);
2003       ggc_mark_tree (lvl->shadowed_labels);
2004       ggc_mark_tree (lvl->blocks);
2005       ggc_mark_tree (lvl->this_block);
2006       ggc_mark_tree (lvl->this_class);
2007       ggc_mark_tree (lvl->incomplete);
2008       ggc_mark_tree (lvl->dead_vars_from_for);
2009     }
2010 }
2011
2012 static void
2013 mark_named_label_lists (labs, uses)
2014      void *labs;
2015      void *uses;
2016 {
2017   struct named_label_list *l = *(struct named_label_list **)labs;
2018   struct named_label_use_list *u = *(struct named_label_use_list **)uses;
2019
2020   for (; l; l = l->next)
2021     {
2022       ggc_mark (l);
2023       mark_binding_level (l->binding_level);
2024       ggc_mark_tree (l->old_value);
2025       ggc_mark_tree (l->label_decl);
2026       ggc_mark_tree (l->bad_decls);
2027     }
2028
2029   for (; u; u = u->next)
2030     ggc_mark (u);
2031 }
2032 \f
2033 /* For debugging.  */
2034 static int no_print_functions = 0;
2035 static int no_print_builtins = 0;
2036
2037 void
2038 print_binding_level (lvl)
2039      struct binding_level *lvl;
2040 {
2041   tree t;
2042   int i = 0, len;
2043   fprintf (stderr, " blocks=");
2044   fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
2045   fprintf (stderr, " n_incomplete=%d parm_flag=%d keep=%d",
2046            list_length (lvl->incomplete), lvl->parm_flag, lvl->keep);
2047   if (lvl->tag_transparent)
2048     fprintf (stderr, " tag-transparent");
2049   if (lvl->more_cleanups_ok)
2050     fprintf (stderr, " more-cleanups-ok");
2051   if (lvl->have_cleanups)
2052     fprintf (stderr, " have-cleanups");
2053   fprintf (stderr, "\n");
2054   if (lvl->names)
2055     {
2056       fprintf (stderr, " names:\t");
2057       /* We can probably fit 3 names to a line?  */
2058       for (t = lvl->names; t; t = TREE_CHAIN (t))
2059         {
2060           if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
2061             continue;
2062           if (no_print_builtins
2063               && (TREE_CODE (t) == TYPE_DECL)
2064               && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
2065             continue;
2066
2067           /* Function decls tend to have longer names.  */
2068           if (TREE_CODE (t) == FUNCTION_DECL)
2069             len = 3;
2070           else
2071             len = 2;
2072           i += len;
2073           if (i > 6)
2074             {
2075               fprintf (stderr, "\n\t");
2076               i = len;
2077             }
2078           print_node_brief (stderr, "", t, 0);
2079           if (t == error_mark_node)
2080             break;
2081         }
2082       if (i)
2083         fprintf (stderr, "\n");
2084     }
2085   if (lvl->tags)
2086     {
2087       fprintf (stderr, " tags:\t");
2088       i = 0;
2089       for (t = lvl->tags; t; t = TREE_CHAIN (t))
2090         {
2091           if (TREE_PURPOSE (t) == NULL_TREE)
2092             len = 3;
2093           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2094             len = 2;
2095           else
2096             len = 4;
2097           i += len;
2098           if (i > 5)
2099             {
2100               fprintf (stderr, "\n\t");
2101               i = len;
2102             }
2103           if (TREE_PURPOSE (t) == NULL_TREE)
2104             {
2105               print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
2106               fprintf (stderr, ">");
2107             }
2108           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2109             print_node_brief (stderr, "", TREE_VALUE (t), 0);
2110           else
2111             {
2112               print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
2113               print_node_brief (stderr, "", TREE_VALUE (t), 0);
2114               fprintf (stderr, ">");
2115             }
2116         }
2117       if (i)
2118         fprintf (stderr, "\n");
2119     }
2120   if (lvl->class_shadowed)
2121     {
2122       fprintf (stderr, " class-shadowed:");
2123       for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
2124         {
2125           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2126         }
2127       fprintf (stderr, "\n");
2128     }
2129   if (lvl->type_shadowed)
2130     {
2131       fprintf (stderr, " type-shadowed:");
2132       for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
2133         {
2134           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2135         }
2136       fprintf (stderr, "\n");
2137     }
2138 }
2139
2140 void
2141 print_other_binding_stack (stack)
2142      struct binding_level *stack;
2143 {
2144   struct binding_level *level;
2145   for (level = stack; level != global_binding_level; level = level->level_chain)
2146     {
2147       fprintf (stderr, "binding level ");
2148       fprintf (stderr, HOST_PTR_PRINTF, level);
2149       fprintf (stderr, "\n");
2150       print_binding_level (level);
2151     }
2152 }
2153
2154 void
2155 print_binding_stack ()
2156 {
2157   struct binding_level *b;
2158   fprintf (stderr, "current_binding_level=");
2159   fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
2160   fprintf (stderr, "\nclass_binding_level=");
2161   fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
2162   fprintf (stderr, "\nglobal_binding_level=");
2163   fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
2164   fprintf (stderr, "\n");
2165   if (class_binding_level)
2166     {
2167       for (b = class_binding_level; b; b = b->level_chain)
2168         if (b == current_binding_level)
2169           break;
2170       if (b)
2171         b = class_binding_level;
2172       else
2173         b = current_binding_level;
2174     }
2175   else
2176     b = current_binding_level;
2177   print_other_binding_stack (b);
2178   fprintf (stderr, "global:\n");
2179   print_binding_level (global_binding_level);
2180 }
2181
2182 /* Namespace binding access routines: The namespace_bindings field of
2183    the identifier is polymorphic, with three possible values:
2184    NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2185    indicating the BINDING_VALUE of global_namespace. */
2186
2187 /* Check whether the a binding for the name to scope is known.
2188    Assumes that the bindings of the name are already a list
2189    of bindings. Returns the binding found, or NULL_TREE. */
2190
2191 static tree
2192 find_binding (name, scope)
2193      tree name;
2194      tree scope;
2195 {
2196   tree iter, prev = NULL_TREE;
2197
2198   scope = ORIGINAL_NAMESPACE (scope);
2199
2200   for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2201        iter = TREE_CHAIN (iter))
2202     {
2203       my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2204       if (BINDING_SCOPE (iter) == scope)
2205         {
2206           /* Move binding found to the front of the list, so
2207              subsequent lookups will find it faster. */
2208           if (prev)
2209             {
2210               TREE_CHAIN (prev) = TREE_CHAIN (iter);
2211               TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2212               IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2213             }
2214           return iter;
2215         }
2216       prev = iter;
2217     }
2218   return NULL_TREE;
2219 }
2220
2221 /* Always returns a binding for name in scope. If the
2222    namespace_bindings is not a list, convert it to one first.
2223    If no binding is found, make a new one. */
2224
2225 tree
2226 binding_for_name (name, scope)
2227      tree name;
2228      tree scope;
2229 {
2230   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2231   tree result;
2232
2233   scope = ORIGINAL_NAMESPACE (scope);
2234
2235   if (b && TREE_CODE (b) != CPLUS_BINDING)
2236     {
2237       /* Get rid of optimization for global scope. */
2238       IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2239       BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2240       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2241     }
2242   if (b && (result = find_binding (name, scope)))
2243     return result;
2244   /* Not found, make a new one. */
2245   result = make_node (CPLUS_BINDING);
2246   TREE_CHAIN (result) = b;
2247   IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2248   BINDING_SCOPE (result) = scope;
2249   BINDING_TYPE (result) = NULL_TREE;
2250   BINDING_VALUE (result) = NULL_TREE;
2251   return result;
2252 }
2253
2254 /* Return the binding value for name in scope, considering that
2255    namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2256
2257 tree
2258 namespace_binding (name, scope)
2259      tree name;
2260      tree scope;
2261 {
2262   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2263   if (b == NULL_TREE)
2264     return NULL_TREE;
2265   if (scope == NULL_TREE)
2266     scope = global_namespace;
2267   if (TREE_CODE (b) != CPLUS_BINDING)
2268     return (scope == global_namespace) ? b : NULL_TREE;
2269   name = find_binding (name,scope);
2270   if (name == NULL_TREE)
2271     return name;
2272   return BINDING_VALUE (name);
2273 }
2274
2275 /* Set the binding value for name in scope. If modifying the binding
2276    of global_namespace is attempted, try to optimize it. */
2277
2278 void
2279 set_namespace_binding (name, scope, val)
2280      tree name;
2281      tree scope;
2282      tree val;
2283 {
2284   tree b;
2285
2286   if (scope == NULL_TREE)
2287     scope = global_namespace;
2288
2289   if (scope == global_namespace)
2290     {
2291       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2292       if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2293         {
2294           IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2295           return;
2296         }
2297     }
2298   b = binding_for_name (name, scope);
2299   BINDING_VALUE (b) = val;
2300 }
2301
2302 /* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
2303    select a name that is unique to this compilation unit.  */
2304
2305 void
2306 push_namespace (name)
2307      tree name;
2308 {
2309   tree d = NULL_TREE;
2310   int need_new = 1;
2311   int implicit_use = 0;
2312   int global = 0;
2313   if (!global_namespace)
2314     {
2315       /* This must be ::. */
2316       my_friendly_assert (name == get_identifier ("::"), 377);
2317       global = 1;
2318     }
2319   else if (!name)
2320     {
2321       /* The name of anonymous namespace is unique for the translation
2322          unit.  */
2323       if (!anonymous_namespace_name)
2324         anonymous_namespace_name = get_file_function_name ('N');
2325       name = anonymous_namespace_name;
2326       d = IDENTIFIER_NAMESPACE_VALUE (name);
2327       if (d)
2328         /* Reopening anonymous namespace.  */
2329         need_new = 0;
2330       implicit_use = 1;
2331     }
2332   else if (current_namespace == global_namespace
2333            && name == DECL_NAME (std_node))
2334     {
2335       in_std++;
2336       return;
2337     }
2338   else
2339     {
2340       /* Check whether this is an extended namespace definition. */
2341       d = IDENTIFIER_NAMESPACE_VALUE (name);
2342       if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2343         {
2344           need_new = 0;
2345           if (DECL_NAMESPACE_ALIAS (d))
2346             {
2347               cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
2348                         d, DECL_NAMESPACE_ALIAS (d));
2349               d = DECL_NAMESPACE_ALIAS (d);
2350             }
2351         }
2352     }
2353
2354   if (need_new)
2355     {
2356       /* Make a new namespace, binding the name to it. */
2357       d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2358       /* The global namespace is not pushed, and the global binding
2359          level is set elsewhere.  */
2360       if (!global)
2361         {
2362           d = pushdecl (d);
2363           pushlevel (0);
2364           declare_namespace_level ();
2365           NAMESPACE_LEVEL (d) = current_binding_level;
2366         }
2367     }
2368   else
2369     resume_binding_level (NAMESPACE_LEVEL (d));
2370
2371   if (implicit_use)
2372     do_using_directive (d);
2373   /* Enter the name space. */
2374   current_namespace = d;
2375 }
2376
2377 /* Pop from the scope of the current namespace.  */
2378
2379 void
2380 pop_namespace ()
2381 {
2382   if (current_namespace == global_namespace)
2383     {
2384       my_friendly_assert (in_std>0, 980421);
2385       in_std--;
2386       return;
2387     }
2388   current_namespace = CP_DECL_CONTEXT (current_namespace);
2389   /* The binding level is not popped, as it might be re-opened later.  */
2390   suspend_binding_level ();
2391 }
2392
2393 /* Push into the scope of the namespace NS, even if it is deeply
2394    nested within another namespace.  */
2395
2396 void
2397 push_nested_namespace (ns)
2398      tree ns;
2399 {
2400   if (ns == global_namespace)
2401     push_to_top_level ();
2402   else
2403     {
2404       push_nested_namespace (CP_DECL_CONTEXT (ns));
2405       push_namespace (DECL_NAME (ns));
2406     }
2407 }
2408
2409 /* Pop back from the scope of the namespace NS, which was previously
2410    entered with push_nested_namespace.  */
2411
2412 void
2413 pop_nested_namespace (ns)
2414      tree ns;
2415 {
2416   while (ns != global_namespace)
2417     {
2418       pop_namespace ();
2419       ns = CP_DECL_CONTEXT (ns);
2420     }
2421
2422   pop_from_top_level ();
2423 }
2424
2425 \f
2426 /* Subroutines for reverting temporarily to top-level for instantiation
2427    of templates and such.  We actually need to clear out the class- and
2428    local-value slots of all identifiers, so that only the global values
2429    are at all visible.  Simply setting current_binding_level to the global
2430    scope isn't enough, because more binding levels may be pushed.  */
2431 struct saved_scope *scope_chain;
2432
2433 /* Mark ST for GC.  */
2434
2435 static void
2436 mark_stmt_tree (st)
2437      struct stmt_tree *st;
2438 {
2439   ggc_mark_tree (st->x_last_stmt);
2440   ggc_mark_tree (st->x_last_expr_type);
2441 }
2442
2443 /* Mark ARG (which is really a struct saved_scope **) for GC.  */
2444
2445 static void
2446 mark_saved_scope (arg)
2447      void *arg;
2448 {
2449   struct saved_scope *t = *(struct saved_scope **)arg;
2450   while (t)
2451     {
2452       mark_binding_level (&t->class_bindings);
2453       ggc_mark_tree (t->old_bindings);
2454       ggc_mark_tree (t->old_namespace);
2455       ggc_mark_tree (t->class_name);
2456       ggc_mark_tree (t->class_type);
2457       ggc_mark_tree (t->access_specifier);
2458       ggc_mark_tree (t->function_decl);
2459       if (t->lang_base)
2460         ggc_mark_tree_varray (t->lang_base);
2461       ggc_mark_tree (t->lang_name);
2462       ggc_mark_tree (t->x_function_parms);
2463       ggc_mark_tree (t->template_parms);
2464       ggc_mark_tree (t->x_previous_class_type);
2465       ggc_mark_tree (t->x_previous_class_values);
2466       ggc_mark_tree (t->x_saved_tree);
2467       ggc_mark_tree (t->incomplete);
2468       ggc_mark_tree (t->lookups);
2469
2470       mark_stmt_tree (&t->x_stmt_tree);
2471       mark_binding_level (&t->bindings);
2472       t = t->prev;
2473     }
2474 }
2475
2476 static tree
2477 store_bindings (names, old_bindings)
2478      tree names, old_bindings;
2479 {
2480   tree t;
2481   for (t = names; t; t = TREE_CHAIN (t))
2482     {
2483       tree binding, t1, id;
2484
2485       if (TREE_CODE (t) == TREE_LIST)
2486         id = TREE_PURPOSE (t);
2487       else
2488         id = DECL_NAME (t);
2489
2490       if (!id
2491           /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2492              we have no IDENTIFIER_BINDING if we have left the class
2493              scope, but cached the class-level declarations.  */
2494           || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2495         continue;
2496
2497       for (t1 = old_bindings; t1; t1 = TREE_CHAIN (t1))
2498         if (TREE_VEC_ELT (t1, 0) == id)
2499           goto skip_it;
2500
2501       binding = make_tree_vec (4);
2502
2503       if (id)
2504         {
2505           my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2506           TREE_VEC_ELT (binding, 0) = id;
2507           TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2508           TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2509           TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2510           IDENTIFIER_BINDING (id) = NULL_TREE;
2511           IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2512         }
2513       TREE_CHAIN (binding) = old_bindings;
2514       old_bindings = binding;
2515     skip_it:
2516       ;
2517     }
2518   return old_bindings;
2519 }
2520
2521 void
2522 maybe_push_to_top_level (pseudo)
2523      int pseudo;
2524 {
2525   struct saved_scope *s;
2526   struct binding_level *b;
2527   tree old_bindings;
2528   int need_pop;
2529
2530   s = (struct saved_scope *) xcalloc (1, sizeof (struct saved_scope));
2531
2532   b = scope_chain ? current_binding_level : 0;
2533
2534   /* If we're in the middle of some function, save our state.  */
2535   if (cfun)
2536     {
2537       need_pop = 1;
2538       push_function_context_to (NULL_TREE);
2539     }
2540   else
2541     need_pop = 0;
2542
2543   old_bindings = NULL_TREE;
2544   if (scope_chain && previous_class_type)
2545     old_bindings = store_bindings (previous_class_values, old_bindings);
2546
2547   /* Have to include global_binding_level, because class-level decls
2548      aren't listed anywhere useful.  */
2549   for (; b; b = b->level_chain)
2550     {
2551       tree t;
2552
2553       /* Template IDs are inserted into the global level. If they were
2554          inserted into namespace level, finish_file wouldn't find them
2555          when doing pending instantiations. Therefore, don't stop at
2556          namespace level, but continue until :: .  */
2557       if (b == global_binding_level || (pseudo && b->template_parms_p))
2558         break;
2559
2560       old_bindings = store_bindings (b->names, old_bindings);
2561       /* We also need to check class_shadowed to save class-level type
2562          bindings, since pushclass doesn't fill in b->names.  */
2563       if (b->parm_flag == 2)
2564         old_bindings = store_bindings (b->class_shadowed, old_bindings);
2565
2566       /* Unwind type-value slots back to top level.  */
2567       for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2568         SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2569     }
2570   s->prev = scope_chain;
2571   s->old_bindings = old_bindings;
2572   s->bindings = b;
2573   s->need_pop_function_context = need_pop;
2574   s->function_decl = current_function_decl;
2575
2576   scope_chain = s;
2577   current_function_decl = NULL_TREE;
2578   VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2579   current_lang_stack = &VARRAY_TREE (current_lang_base, 0);
2580   current_lang_name = lang_name_cplusplus;
2581   strict_prototype = strict_prototypes_lang_cplusplus;
2582   current_namespace = global_namespace;
2583 }
2584
2585 void
2586 push_to_top_level ()
2587 {
2588   maybe_push_to_top_level (0);
2589 }
2590
2591 void
2592 pop_from_top_level ()
2593 {
2594   struct saved_scope *s = scope_chain;
2595   tree t;
2596
2597   /* Clear out class-level bindings cache.  */
2598   if (previous_class_type)
2599     invalidate_class_lookup_cache ();
2600
2601   VARRAY_FREE (current_lang_base);
2602
2603   scope_chain = s->prev;
2604   for (t = s->old_bindings; t; t = TREE_CHAIN (t))
2605     {
2606       tree id = TREE_VEC_ELT (t, 0);
2607       if (id)
2608         {
2609           SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2610           IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2611           IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2612         }
2613     }
2614
2615   if (current_lang_name == lang_name_cplusplus)
2616     strict_prototype = strict_prototypes_lang_cplusplus;
2617   else if (current_lang_name == lang_name_c)
2618     strict_prototype = strict_prototypes_lang_c;
2619
2620   /* If we were in the middle of compiling a function, restore our
2621      state.  */
2622   if (s->need_pop_function_context)
2623     pop_function_context_from (NULL_TREE);
2624   current_function_decl = s->function_decl;
2625
2626   free (s);
2627 }
2628 \f
2629 /* Push a definition of struct, union or enum tag "name".
2630    into binding_level "b".   "type" should be the type node,
2631    We assume that the tag "name" is not already defined.
2632
2633    Note that the definition may really be just a forward reference.
2634    In that case, the TYPE_SIZE will be a NULL_TREE.
2635
2636    C++ gratuitously puts all these tags in the name space.  */
2637
2638 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2639    record the shadowed value for this binding contour.  TYPE is
2640    the type that ID maps to.  */
2641
2642 static void
2643 set_identifier_type_value_with_scope (id, type, b)
2644      tree id;
2645      tree type;
2646      struct binding_level *b;
2647 {
2648   if (!b->namespace_p)
2649     {
2650       /* Shadow the marker, not the real thing, so that the marker
2651          gets restored later. */
2652       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2653       b->type_shadowed
2654         = tree_cons (id, old_type_value, b->type_shadowed);
2655     }
2656   else
2657     {
2658       tree binding = binding_for_name (id, current_namespace);
2659       BINDING_TYPE (binding) = type;
2660       /* Store marker instead of real type. */
2661       type = global_type_node;
2662     }
2663   SET_IDENTIFIER_TYPE_VALUE (id, type);
2664 }
2665
2666 /* As set_identifier_type_value_with_scope, but using current_binding_level.  */
2667
2668 void
2669 set_identifier_type_value (id, type)
2670      tree id;
2671      tree type;
2672 {
2673   set_identifier_type_value_with_scope (id, type, current_binding_level);
2674 }
2675
2676 /* Return the type associated with id. */
2677
2678 tree
2679 identifier_type_value (id)
2680      tree id;
2681 {
2682   /* There is no type with that name, anywhere. */
2683   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2684     return NULL_TREE;
2685   /* This is not the type marker, but the real thing. */
2686   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2687     return REAL_IDENTIFIER_TYPE_VALUE (id);
2688   /* Have to search for it. It must be on the global level, now.
2689      Ask lookup_name not to return non-types. */
2690   id = lookup_name_real (id, 2, 1, 0);
2691   if (id)
2692     return TREE_TYPE (id);
2693   return NULL_TREE;
2694 }
2695
2696 /* Pop off extraneous binding levels left over due to syntax errors.
2697
2698    We don't pop past namespaces, as they might be valid.  */
2699
2700 void
2701 pop_everything ()
2702 {
2703 #ifdef DEBUG_CP_BINDING_LEVELS
2704   fprintf (stderr, "XXX entering pop_everything ()\n");
2705 #endif
2706   while (!toplevel_bindings_p ())
2707     {
2708       if (current_binding_level->parm_flag == 2)
2709         pop_nested_class ();
2710       else
2711         poplevel (0, 0, 0);
2712     }
2713 #ifdef DEBUG_CP_BINDING_LEVELS
2714   fprintf (stderr, "XXX leaving pop_everything ()\n");
2715 #endif
2716 }
2717
2718 /* The type TYPE is being declared.  If it is a class template, or a
2719    specialization of a class template, do any processing required and
2720    perform error-checking.  If IS_FRIEND is non-zero, this TYPE is
2721    being declared a friend.  B is the binding level at which this TYPE
2722    should be bound.
2723
2724    Returns the TYPE_DECL for TYPE, which may have been altered by this
2725    processing.  */
2726
2727 static tree
2728 maybe_process_template_type_declaration (type, globalize, b)
2729      tree type;
2730      int globalize;
2731      struct binding_level* b;
2732 {
2733   tree decl = TYPE_NAME (type);
2734
2735   if (processing_template_parmlist)
2736     /* You can't declare a new template type in a template parameter
2737        list.  But, you can declare a non-template type:
2738
2739          template <class A*> struct S;
2740
2741        is a forward-declaration of `A'.  */
2742     ;
2743   else
2744     {
2745       maybe_check_template_type (type);
2746
2747       my_friendly_assert (IS_AGGR_TYPE (type)
2748                           || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2749
2750
2751       if (processing_template_decl)
2752         {
2753           /* This may change after the call to
2754              push_template_decl_real, but we want the original value.  */
2755           tree name = DECL_NAME (decl);
2756
2757           decl = push_template_decl_real (decl, globalize);
2758           /* If the current binding level is the binding level for the
2759              template parameters (see the comment in
2760              begin_template_parm_list) and the enclosing level is a class
2761              scope, and we're not looking at a friend, push the
2762              declaration of the member class into the class scope.  In the
2763              friend case, push_template_decl will already have put the
2764              friend into global scope, if appropriate.  */
2765           if (TREE_CODE (type) != ENUMERAL_TYPE
2766               && !globalize && b->template_parms_p
2767               && b->level_chain->parm_flag == 2)
2768             {
2769               finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2770               /* Put this tag on the list of tags for the class, since
2771                  that won't happen below because B is not the class
2772                  binding level, but is instead the pseudo-global level.  */
2773               b->level_chain->tags =
2774                 tree_cons (name, type, b->level_chain->tags);
2775               if (!COMPLETE_TYPE_P (current_class_type))
2776                 CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2777             }
2778         }
2779     }
2780
2781   return decl;
2782 }
2783
2784 /* In C++, you don't have to write `struct S' to refer to `S'; you
2785    can just use `S'.  We accomplish this by creating a TYPE_DECL as
2786    if the user had written `typedef struct S S'.  Create and return
2787    the TYPE_DECL for TYPE.  */
2788
2789 tree
2790 create_implicit_typedef (name, type)
2791      tree name;
2792      tree type;
2793 {
2794   tree decl;
2795
2796   decl = build_decl (TYPE_DECL, name, type);
2797   SET_DECL_ARTIFICIAL (decl);
2798   /* There are other implicit type declarations, like the one *within*
2799      a class that allows you to write `S::S'.  We must distinguish
2800      amongst these.  */
2801   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2802   TYPE_NAME (type) = decl;
2803
2804   return decl;
2805 }
2806
2807 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2808    Normally put it into the inner-most non-tag-transparent scope,
2809    but if GLOBALIZE is true, put it in the inner-most non-class scope.
2810    The latter is needed for implicit declarations.  */
2811
2812 void
2813 pushtag (name, type, globalize)
2814      tree name, type;
2815      int globalize;
2816 {
2817   register struct binding_level *b;
2818
2819   b = current_binding_level;
2820   while (b->tag_transparent
2821          || (globalize && b->parm_flag == 2))
2822     b = b->level_chain;
2823
2824   b->tags = tree_cons (name, type, b->tags);
2825
2826   if (name)
2827     {
2828       /* Do C++ gratuitous typedefing.  */
2829       if (IDENTIFIER_TYPE_VALUE (name) != type)
2830         {
2831           register tree d = NULL_TREE;
2832           int in_class = 0;
2833           tree context = TYPE_CONTEXT (type);
2834
2835           if (! context)
2836             {
2837               tree cs = current_scope ();
2838
2839               if (! globalize)
2840                 context = cs;
2841               else if (cs != NULL_TREE && TYPE_P (cs))
2842                 /* When declaring a friend class of a local class, we want
2843                    to inject the newly named class into the scope
2844                    containing the local class, not the namespace scope.  */
2845                 context = decl_function_context (get_type_decl (cs));
2846             }
2847           if (!context)
2848             context = current_namespace;
2849
2850           if ((b->template_parms_p && b->level_chain->parm_flag == 2)
2851               || b->parm_flag == 2)
2852             in_class = 1;
2853
2854           if (current_lang_name == lang_name_java)
2855             TYPE_FOR_JAVA (type) = 1;
2856
2857           d = create_implicit_typedef (name, type);
2858           DECL_CONTEXT (d) = FROB_CONTEXT (context);
2859           if (! in_class)
2860             set_identifier_type_value_with_scope (name, type, b);
2861
2862           d = maybe_process_template_type_declaration (type,
2863                                                        globalize, b);
2864
2865           if (b->parm_flag == 2)
2866             {
2867               if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2868                 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2869                    class.  But if it's a member template class, we
2870                    want the TEMPLATE_DECL, not the TYPE_DECL, so this
2871                    is done later.  */
2872                 finish_member_declaration (d);
2873               else
2874                 pushdecl_class_level (d);
2875             }
2876           else
2877             d = pushdecl_with_scope (d, b);
2878
2879           if (ANON_AGGRNAME_P (name))
2880             DECL_IGNORED_P (d) = 1;
2881
2882           TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2883           DECL_ASSEMBLER_NAME (d) = DECL_NAME (d);
2884           if (!uses_template_parms (type))
2885             DECL_ASSEMBLER_NAME (d)
2886               = get_identifier (build_overload_name (type, 1, 1));
2887         }
2888       if (b->parm_flag == 2)
2889         {
2890           if (!COMPLETE_TYPE_P (current_class_type))
2891             CLASSTYPE_TAGS (current_class_type) = b->tags;
2892         }
2893     }
2894
2895   if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2896     /* Use the canonical TYPE_DECL for this node.  */
2897     TYPE_STUB_DECL (type) = TYPE_NAME (type);
2898   else
2899     {
2900       /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2901          will be the tagged type we just added to the current
2902          binding level.  This fake NULL-named TYPE_DECL node helps
2903          dwarfout.c to know when it needs to output a
2904          representation of a tagged type, and it also gives us a
2905          convenient place to record the "scope start" address for
2906          the tagged type.  */
2907
2908       tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2909       TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2910     }
2911 }
2912
2913 /* Counter used to create anonymous type names.  */
2914
2915 static int anon_cnt = 0;
2916
2917 /* Return an IDENTIFIER which can be used as a name for
2918    anonymous structs and unions.  */
2919
2920 tree
2921 make_anon_name ()
2922 {
2923   char buf[32];
2924
2925   sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2926   return get_identifier (buf);
2927 }
2928
2929 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2930    This keeps dbxout from getting confused.  */
2931
2932 void
2933 clear_anon_tags ()
2934 {
2935   register struct binding_level *b;
2936   register tree tags;
2937   static int last_cnt = 0;
2938
2939   /* Fast out if no new anon names were declared.  */
2940   if (last_cnt == anon_cnt)
2941     return;
2942
2943   b = current_binding_level;
2944   while (b->tag_transparent)
2945     b = b->level_chain;
2946   tags = b->tags;
2947   while (tags)
2948     {
2949       /* A NULL purpose means we have already processed all tags
2950          from here to the end of the list.  */
2951       if (TREE_PURPOSE (tags) == NULL_TREE)
2952         break;
2953       if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2954         TREE_PURPOSE (tags) = NULL_TREE;
2955       tags = TREE_CHAIN (tags);
2956     }
2957   last_cnt = anon_cnt;
2958 }
2959 \f
2960 /* Subroutine of duplicate_decls: return truthvalue of whether
2961    or not types of these decls match.
2962
2963    For C++, we must compare the parameter list so that `int' can match
2964    `int&' in a parameter position, but `int&' is not confused with
2965    `const int&'.  */
2966
2967 int
2968 decls_match (newdecl, olddecl)
2969      tree newdecl, olddecl;
2970 {
2971   int types_match;
2972
2973   if (newdecl == olddecl)
2974     return 1;
2975
2976   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
2977     /* If the two DECLs are not even the same kind of thing, we're not
2978        interested in their types.  */
2979     return 0;
2980
2981   if (TREE_CODE (newdecl) == FUNCTION_DECL)
2982     {
2983       tree f1 = TREE_TYPE (newdecl);
2984       tree f2 = TREE_TYPE (olddecl);
2985       tree p1 = TYPE_ARG_TYPES (f1);
2986       tree p2 = TYPE_ARG_TYPES (f2);
2987
2988       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
2989           && ! (DECL_EXTERN_C_P (newdecl)
2990                 && DECL_EXTERN_C_P (olddecl)))
2991         return 0;
2992
2993       if (TREE_CODE (f1) != TREE_CODE (f2))
2994         return 0;
2995
2996       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
2997         {
2998           if ((! strict_prototypes_lang_c || DECL_BUILT_IN (olddecl))
2999               && DECL_EXTERN_C_P (olddecl)
3000               && p2 == NULL_TREE)
3001             {
3002               types_match = self_promoting_args_p (p1);
3003               if (p1 == void_list_node)
3004                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
3005             }
3006           else if (!strict_prototypes_lang_c
3007                    && DECL_EXTERN_C_P (olddecl)
3008                    && DECL_EXTERN_C_P (newdecl)
3009                    && p1 == NULL_TREE)
3010             {
3011               types_match = self_promoting_args_p (p2);
3012               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
3013             }
3014           else
3015             types_match = compparms (p1, p2);
3016         }
3017       else
3018         types_match = 0;
3019     }
3020   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3021     {
3022       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3023                                 DECL_TEMPLATE_PARMS (olddecl)))
3024         return 0;
3025
3026       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3027         types_match = 1;
3028       else
3029         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
3030                                    DECL_TEMPLATE_RESULT (newdecl));
3031     }
3032   else
3033     {
3034       if (TREE_TYPE (newdecl) == error_mark_node)
3035         types_match = TREE_TYPE (olddecl) == error_mark_node;
3036       else if (TREE_TYPE (olddecl) == NULL_TREE)
3037         types_match = TREE_TYPE (newdecl) == NULL_TREE;
3038       else if (TREE_TYPE (newdecl) == NULL_TREE)
3039         types_match = 0;
3040       else
3041         types_match = comptypes (TREE_TYPE (newdecl),
3042                                  TREE_TYPE (olddecl),
3043                                  COMPARE_REDECLARATION);
3044     }
3045
3046   return types_match;
3047 }
3048
3049 /* If NEWDECL is `static' and an `extern' was seen previously,
3050    warn about it.  OLDDECL is the previous declaration.
3051
3052    Note that this does not apply to the C++ case of declaring
3053    a variable `extern const' and then later `const'.
3054
3055    Don't complain about built-in functions, since they are beyond
3056    the user's control.  */
3057
3058 static void
3059 warn_extern_redeclared_static (newdecl, olddecl)
3060      tree newdecl, olddecl;
3061 {
3062   static const char *explicit_extern_static_warning
3063     = "`%D' was declared `extern' and later `static'";
3064   static const char *implicit_extern_static_warning
3065     = "`%D' was declared implicitly `extern' and later `static'";
3066
3067   tree name;
3068
3069   if (TREE_CODE (newdecl) == TYPE_DECL
3070       || TREE_CODE (newdecl) == TEMPLATE_DECL)
3071     return;
3072
3073   /* Don't get confused by static member functions; that's a different
3074      use of `static'.  */
3075   if (TREE_CODE (newdecl) == FUNCTION_DECL
3076       && DECL_STATIC_FUNCTION_P (newdecl))
3077     return;
3078
3079   /* If the old declaration was `static', or the new one isn't, then
3080      then everything is OK.  */
3081   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
3082     return;
3083
3084   /* It's OK to declare a builtin function as `static'.  */
3085   if (TREE_CODE (olddecl) == FUNCTION_DECL
3086       && DECL_ARTIFICIAL (olddecl))
3087     return;
3088
3089   name = DECL_ASSEMBLER_NAME (newdecl);
3090   cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
3091               ? implicit_extern_static_warning
3092               : explicit_extern_static_warning, newdecl);
3093   cp_pedwarn_at ("previous declaration of `%D'", olddecl);
3094 }
3095
3096 /* Handle when a new declaration NEWDECL has the same name as an old
3097    one OLDDECL in the same binding contour.  Prints an error message
3098    if appropriate.
3099
3100    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
3101    Otherwise, return 0.  */
3102
3103 int
3104 duplicate_decls (newdecl, olddecl)
3105      tree newdecl, olddecl;
3106 {
3107   unsigned olddecl_uid = DECL_UID (olddecl);
3108   int olddecl_friend = 0, types_match = 0;
3109   int new_defines_function = 0;
3110
3111   if (newdecl == olddecl)
3112     return 1;
3113
3114   types_match = decls_match (newdecl, olddecl);
3115
3116   /* If either the type of the new decl or the type of the old decl is an
3117      error_mark_node, then that implies that we have already issued an
3118      error (earlier) for some bogus type specification, and in that case,
3119      it is rather pointless to harass the user with yet more error message
3120      about the same declaration, so just pretend the types match here.  */
3121   if (TREE_TYPE (newdecl) == error_mark_node
3122       || TREE_TYPE (olddecl) == error_mark_node)
3123     types_match = 1;
3124
3125   /* Check for redeclaration and other discrepancies. */
3126   if (TREE_CODE (olddecl) == FUNCTION_DECL
3127       && DECL_ARTIFICIAL (olddecl))
3128     {
3129       if (TREE_CODE (newdecl) != FUNCTION_DECL)
3130         {
3131           /* If you declare a built-in or predefined function name as static,
3132              the old definition is overridden, but optionally warn this was a
3133              bad choice of name.  */
3134           if (! TREE_PUBLIC (newdecl))
3135             {
3136               if (warn_shadow)
3137                 cp_warning ("shadowing %s function `%#D'",
3138                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3139                             olddecl);
3140               /* Discard the old built-in function.  */
3141               return 0;
3142             }
3143           /* If the built-in is not ansi, then programs can override
3144              it even globally without an error.  */
3145           else if (! DECL_BUILT_IN (olddecl))
3146             cp_warning ("library function `%#D' redeclared as non-function `%#D'",
3147                         olddecl, newdecl);
3148           else
3149             {
3150               cp_error ("declaration of `%#D'", newdecl);
3151               cp_error ("conflicts with built-in declaration `%#D'",
3152                         olddecl);
3153             }
3154           return 0;
3155         }
3156       else if (!types_match)
3157         {
3158           if ((DECL_EXTERN_C_P (newdecl)
3159                && DECL_EXTERN_C_P (olddecl))
3160               || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3161                             TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3162             {
3163               /* A near match; override the builtin.  */
3164
3165               if (TREE_PUBLIC (newdecl))
3166                 {
3167                   cp_warning ("new declaration `%#D'", newdecl);
3168                   cp_warning ("ambiguates built-in declaration `%#D'",
3169                               olddecl);
3170                 }
3171               else if (warn_shadow)
3172                 cp_warning ("shadowing %s function `%#D'",
3173                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3174                             olddecl);
3175             }
3176           else
3177             /* Discard the old built-in function.  */
3178             return 0;
3179         }
3180
3181       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3182         {
3183           /* If a builtin function is redeclared as `static', merge
3184              the declarations, but make the original one static.  */
3185           DECL_THIS_STATIC (olddecl) = 1;
3186           TREE_PUBLIC (olddecl) = 0;
3187
3188           /* Make the old declaration consistent with the new one so
3189              that all remnants of the builtin-ness of this function
3190              will be banished.  */
3191           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3192           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3193           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3194           SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (newdecl),
3195                                        newdecl);
3196         }
3197     }
3198   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3199     {
3200       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3201            && TREE_CODE (newdecl) != TYPE_DECL
3202            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3203                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3204           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3205               && TREE_CODE (olddecl) != TYPE_DECL
3206               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3207                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3208                         == TYPE_DECL))))
3209         {
3210           /* We do nothing special here, because C++ does such nasty
3211              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
3212              get shadowed, and know that if we need to find a TYPE_DECL
3213              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3214              slot of the identifier.  */
3215           return 0;
3216         }
3217
3218       if ((TREE_CODE (newdecl) == FUNCTION_DECL
3219            && DECL_FUNCTION_TEMPLATE_P (olddecl))
3220           || (TREE_CODE (olddecl) == FUNCTION_DECL
3221               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3222         return 0;
3223
3224       cp_error ("`%#D' redeclared as different kind of symbol", newdecl);
3225       if (TREE_CODE (olddecl) == TREE_LIST)
3226         olddecl = TREE_VALUE (olddecl);
3227       cp_error_at ("previous declaration of `%#D'", olddecl);
3228
3229       /* New decl is completely inconsistent with the old one =>
3230          tell caller to replace the old one.  */
3231
3232       return 0;
3233     }
3234   else if (!types_match)
3235     {
3236       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
3237         /* These are certainly not duplicate declarations; they're
3238            from different scopes.  */
3239         return 0;
3240
3241       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3242         {
3243           /* The name of a class template may not be declared to refer to
3244              any other template, class, function, object, namespace, value,
3245              or type in the same scope.  */
3246           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3247               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3248             {
3249               cp_error ("declaration of template `%#D'", newdecl);
3250               cp_error_at ("conflicts with previous declaration `%#D'",
3251                            olddecl);
3252             }
3253           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3254                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3255                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3256                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3257                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3258                                            DECL_TEMPLATE_PARMS (olddecl)))
3259             {
3260               cp_error ("new declaration `%#D'", newdecl);
3261               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3262             }
3263           return 0;
3264         }
3265       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3266         {
3267           if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
3268             {
3269               cp_error ("declaration of C function `%#D' conflicts with",
3270                         newdecl);
3271               cp_error_at ("previous declaration `%#D' here", olddecl);
3272             }
3273           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3274                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3275             {
3276               cp_error ("new declaration `%#D'", newdecl);
3277               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3278             }
3279           else
3280             return 0;
3281         }
3282
3283       /* Already complained about this, so don't do so again.  */
3284       else if (current_class_type == NULL_TREE
3285           || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3286         {
3287           cp_error ("conflicting types for `%#D'", newdecl);
3288           cp_error_at ("previous declaration as `%#D'", olddecl);
3289         }
3290     }
3291   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3292             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3293                  && (!DECL_TEMPLATE_INFO (newdecl)
3294                      || (DECL_TI_TEMPLATE (newdecl)
3295                          != DECL_TI_TEMPLATE (olddecl))))
3296                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3297                     && (!DECL_TEMPLATE_INFO (olddecl)
3298                         || (DECL_TI_TEMPLATE (olddecl)
3299                             != DECL_TI_TEMPLATE (newdecl))))))
3300     /* It's OK to have a template specialization and a non-template
3301        with the same type, or to have specializations of two
3302        different templates with the same type.  Note that if one is a
3303        specialization, and the other is an instantiation of the same
3304        template, that we do not exit at this point.  That situation
3305        can occur if we instantiate a template class, and then
3306        specialize one of its methods.  This situation is legal, but
3307        the declarations must be merged in the usual way.  */
3308     return 0;
3309   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3310            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3311                 && !DECL_USE_TEMPLATE (newdecl))
3312                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3313                    && !DECL_USE_TEMPLATE (olddecl))))
3314     /* One of the declarations is a template instantiation, and the
3315        other is not a template at all.  That's OK.  */
3316     return 0;
3317   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3318            && DECL_NAMESPACE_ALIAS (newdecl)
3319            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3320     /* Redeclaration of namespace alias, ignore it. */
3321     return 1;
3322   else
3323     {
3324       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3325       if (errmsg)
3326         {
3327           cp_error (errmsg, newdecl);
3328           if (DECL_NAME (olddecl) != NULL_TREE)
3329             cp_error_at ((DECL_INITIAL (olddecl)
3330                           && namespace_bindings_p ())
3331                          ? "`%#D' previously defined here"
3332                          : "`%#D' previously declared here", olddecl);
3333         }
3334       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3335                && DECL_INITIAL (olddecl) != NULL_TREE
3336                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3337                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3338         {
3339           /* Prototype decl follows defn w/o prototype.  */
3340           cp_warning_at ("prototype for `%#D'", newdecl);
3341           cp_warning_at ("follows non-prototype definition here", olddecl);
3342         }
3343       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3344                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3345         {
3346           /* extern "C" int foo ();
3347              int foo () { bar (); }
3348              is OK.  */
3349           if (current_lang_stack
3350               == &VARRAY_TREE (current_lang_base, 0))
3351             DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3352           else
3353             {
3354               cp_error_at ("previous declaration of `%#D' with %L linkage",
3355                            olddecl, DECL_LANGUAGE (olddecl));
3356               cp_error ("conflicts with new declaration with %L linkage",
3357                         DECL_LANGUAGE (newdecl));
3358             }
3359         }
3360
3361       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3362         ;
3363       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3364         {
3365           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3366           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3367           int i = 1;
3368
3369           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3370             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3371
3372           for (; t1 && t1 != void_list_node;
3373                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3374             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3375               {
3376                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3377                                            TREE_PURPOSE (t2)))
3378                   {
3379                     if (pedantic)
3380                       {
3381                         cp_pedwarn ("default argument given for parameter %d of `%#D'",
3382                                     i, newdecl);
3383                         cp_pedwarn_at ("after previous specification in `%#D'",
3384                                        olddecl);
3385                       }
3386                   }
3387                 else
3388                   {
3389                     cp_error ("default argument given for parameter %d of `%#D'",
3390                               i, newdecl);
3391                     cp_error_at ("after previous specification in `%#D'",
3392                                  olddecl);
3393                   }
3394               }
3395
3396           if (DECL_THIS_INLINE (newdecl) && ! DECL_THIS_INLINE (olddecl)
3397               && TREE_ADDRESSABLE (olddecl) && warn_inline)
3398             {
3399               cp_warning ("`%#D' was used before it was declared inline",
3400                           newdecl);
3401               cp_warning_at ("previous non-inline declaration here",
3402                              olddecl);
3403             }
3404         }
3405     }
3406
3407   /* If new decl is `static' and an `extern' was seen previously,
3408      warn about it.  */
3409   warn_extern_redeclared_static (newdecl, olddecl);
3410
3411   /* We have committed to returning 1 at this point.  */
3412   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3413     {
3414       /* Now that functions must hold information normally held
3415          by field decls, there is extra work to do so that
3416          declaration information does not get destroyed during
3417          definition.  */
3418       if (DECL_VINDEX (olddecl))
3419         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3420       if (DECL_VIRTUAL_CONTEXT (olddecl))
3421         DECL_VIRTUAL_CONTEXT (newdecl) = DECL_VIRTUAL_CONTEXT (olddecl);
3422       if (DECL_CONTEXT (olddecl))
3423         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3424       if (DECL_PENDING_INLINE_INFO (newdecl) == (struct pending_inline *)0)
3425         DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3426       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3427       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3428       DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3429       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3430       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3431       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3432       DECL_LANG_SPECIFIC (newdecl)->u2 = DECL_LANG_SPECIFIC (olddecl)->u2;
3433       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3434
3435       /* Optionally warn about more than one declaration for the same
3436          name, but don't warn about a function declaration followed by a
3437          definition.  */
3438       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3439           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3440           /* Don't warn about extern decl followed by definition. */
3441           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3442           /* Don't warn about friends, let add_friend take care of it. */
3443           && ! DECL_FRIEND_P (newdecl))
3444         {
3445           cp_warning ("redundant redeclaration of `%D' in same scope", newdecl);
3446           cp_warning_at ("previous declaration of `%D'", olddecl);
3447         }
3448     }
3449
3450   /* Deal with C++: must preserve virtual function table size.  */
3451   if (TREE_CODE (olddecl) == TYPE_DECL)
3452     {
3453       register tree newtype = TREE_TYPE (newdecl);
3454       register tree oldtype = TREE_TYPE (olddecl);
3455
3456       if (newtype != error_mark_node && oldtype != error_mark_node
3457           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3458         {
3459           CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
3460           CLASSTYPE_FRIEND_CLASSES (newtype)
3461             = CLASSTYPE_FRIEND_CLASSES (oldtype);
3462         }
3463     }
3464
3465   /* Copy all the DECL_... slots specified in the new decl
3466      except for any that we copy here from the old type.  */
3467   DECL_MACHINE_ATTRIBUTES (newdecl)
3468     = merge_machine_decl_attributes (olddecl, newdecl);
3469
3470   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3471     {
3472       if (! duplicate_decls (DECL_TEMPLATE_RESULT (newdecl),
3473                              DECL_TEMPLATE_RESULT (olddecl)))
3474         cp_error ("invalid redeclaration of %D", newdecl);
3475       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3476       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3477         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3478                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3479
3480       return 1;
3481     }
3482
3483   if (types_match)
3484     {
3485       /* Automatically handles default parameters.  */
3486       tree oldtype = TREE_TYPE (olddecl);
3487       tree newtype;
3488
3489       /* Merge the data types specified in the two decls.  */
3490       newtype = common_type (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3491
3492       if (TREE_CODE (newdecl) == VAR_DECL)
3493         DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3494       /* Do this after calling `common_type' so that default
3495          parameters don't confuse us.  */
3496       else if (TREE_CODE (newdecl) == FUNCTION_DECL
3497           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3498               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3499         {
3500           TREE_TYPE (newdecl) = build_exception_variant (newtype,
3501                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3502           TREE_TYPE (olddecl) = build_exception_variant (newtype,
3503                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
3504
3505           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3506               && DECL_SOURCE_LINE (olddecl) != 0
3507               && flag_exceptions
3508               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3509                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3510             {
3511               cp_error ("declaration of `%F' throws different exceptions",
3512                         newdecl);
3513               cp_error_at ("than previous declaration `%F'", olddecl);
3514             }
3515         }
3516       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3517
3518       /* Lay the type out, unless already done.  */
3519       if (! same_type_p (newtype, oldtype)
3520           && TREE_TYPE (newdecl) != error_mark_node
3521           && !(processing_template_decl && uses_template_parms (newdecl)))
3522         layout_type (TREE_TYPE (newdecl));
3523
3524       if ((TREE_CODE (newdecl) == VAR_DECL
3525            || TREE_CODE (newdecl) == PARM_DECL
3526            || TREE_CODE (newdecl) == RESULT_DECL
3527            || TREE_CODE (newdecl) == FIELD_DECL
3528            || TREE_CODE (newdecl) == TYPE_DECL)
3529           && !(processing_template_decl && uses_template_parms (newdecl)))
3530         layout_decl (newdecl, 0);
3531
3532       /* Merge the type qualifiers.  */
3533       if (TREE_READONLY (newdecl))
3534         TREE_READONLY (olddecl) = 1;
3535       if (TREE_THIS_VOLATILE (newdecl))
3536         TREE_THIS_VOLATILE (olddecl) = 1;
3537
3538       /* Merge the initialization information.  */
3539       if (DECL_INITIAL (newdecl) == NULL_TREE
3540           && DECL_INITIAL (olddecl) != NULL_TREE)
3541         {
3542           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3543           DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
3544           DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
3545           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3546               && DECL_LANG_SPECIFIC (newdecl)
3547               && DECL_LANG_SPECIFIC (olddecl))
3548             DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3549         }
3550
3551       /* Merge the section attribute.
3552          We want to issue an error if the sections conflict but that must be
3553          done later in decl_attributes since we are called before attributes
3554          are assigned.  */
3555       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3556         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3557
3558       /* Keep the old rtl since we can safely use it.  */
3559       DECL_RTL (newdecl) = DECL_RTL (olddecl);
3560
3561       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3562         {
3563           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3564             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3565           DECL_NO_CHECK_MEMORY_USAGE (newdecl)
3566             |= DECL_NO_CHECK_MEMORY_USAGE (olddecl);
3567           DECL_NO_LIMIT_STACK (newdecl)
3568             |= DECL_NO_LIMIT_STACK (olddecl);
3569         }
3570     }
3571   /* If cannot merge, then use the new type and qualifiers,
3572      and don't preserve the old rtl.  */
3573   else
3574     {
3575       /* Clean out any memory we had of the old declaration.  */
3576       tree oldstatic = value_member (olddecl, static_aggregates);
3577       if (oldstatic)
3578         TREE_VALUE (oldstatic) = error_mark_node;
3579
3580       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3581       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3582       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3583       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3584     }
3585
3586   /* Merge the storage class information.  */
3587   DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
3588   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3589   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3590   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3591   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3592   if (! DECL_EXTERNAL (olddecl))
3593     DECL_EXTERNAL (newdecl) = 0;
3594
3595   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3596     {
3597       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3598       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3599       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3600       DECL_TEMPLATE_INSTANTIATED (newdecl)
3601         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3602       /* Don't really know how much of the language-specific
3603          values we should copy from old to new.  */
3604       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3605       DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
3606       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3607       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3608       olddecl_friend = DECL_FRIEND_P (olddecl);
3609
3610       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
3611       if (TREE_CODE (newdecl) == FUNCTION_DECL
3612           || DECL_FUNCTION_TEMPLATE_P (newdecl))
3613         DECL_BEFRIENDING_CLASSES (newdecl)
3614           = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3615                      DECL_BEFRIENDING_CLASSES (olddecl));
3616     }
3617
3618   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3619     {
3620       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3621           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3622         {
3623           /* If newdecl is not a specialization, then it is not a
3624              template-related function at all.  And that means that we
3625              shoud have exited above, returning 0.  */
3626           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3627                               0);
3628
3629           if (TREE_USED (olddecl))
3630             /* From [temp.expl.spec]:
3631
3632                If a template, a member template or the member of a class
3633                template is explicitly specialized then that
3634                specialization shall be declared before the first use of
3635                that specialization that would cause an implicit
3636                instantiation to take place, in every translation unit in
3637                which such a use occurs.  */
3638             cp_error ("explicit specialization of %D after first use",
3639                       olddecl);
3640
3641           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3642         }
3643       DECL_THIS_INLINE (newdecl) |= DECL_THIS_INLINE (olddecl);
3644
3645       /* If either decl says `inline', this fn is inline, unless its
3646          definition was passed already.  */
3647       if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3648         DECL_INLINE (olddecl) = 1;
3649       DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3650
3651       if (! types_match)
3652         {
3653           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3654           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3655           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3656         }
3657       if (! types_match || new_defines_function)
3658         {
3659           /* These need to be copied so that the names are available.
3660              Note that if the types do match, we'll preserve inline
3661              info and other bits, but if not, we won't.  */
3662           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3663           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3664         }
3665       if (new_defines_function)
3666         /* If defining a function declared with other language
3667            linkage, use the previously declared language linkage.  */
3668         DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3669       else if (types_match)
3670         {
3671           /* If redeclaring a builtin function, and not a definition,
3672              it stays built in.  */
3673           if (DECL_BUILT_IN (olddecl))
3674             {
3675               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3676               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3677               /* If we're keeping the built-in definition, keep the rtl,
3678                  regardless of declaration matches.  */
3679               DECL_RTL (newdecl) = DECL_RTL (olddecl);
3680             }
3681           else
3682             DECL_FRAME_SIZE (newdecl) = DECL_FRAME_SIZE (olddecl);
3683
3684           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3685           if ((DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl)))
3686             /* Previously saved insns go together with
3687                the function's previous definition.  */
3688             DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3689           /* Don't clear out the arguments if we're redefining a function.  */
3690           if (DECL_ARGUMENTS (olddecl))
3691             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3692         }
3693     }
3694
3695   if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3696     {
3697       NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3698     }
3699
3700   /* Now preserve various other info from the definition.  */
3701   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3702   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3703   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3704   DECL_ASSEMBLER_NAME (newdecl) = DECL_ASSEMBLER_NAME (olddecl);
3705
3706   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3707     {
3708       int function_size;
3709
3710       function_size = sizeof (struct tree_decl);
3711
3712       bcopy ((char *) newdecl + sizeof (struct tree_common),
3713              (char *) olddecl + sizeof (struct tree_common),
3714              function_size - sizeof (struct tree_common));
3715
3716       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3717         {
3718           /* If newdecl is a template instantiation, it is possible that
3719              the following sequence of events has occurred:
3720
3721              o A friend function was declared in a class template.  The
3722              class template was instantiated.
3723
3724              o The instantiation of the friend declaration was
3725              recorded on the instantiation list, and is newdecl.
3726
3727              o Later, however, instantiate_class_template called pushdecl
3728              on the newdecl to perform name injection.  But, pushdecl in
3729              turn called duplicate_decls when it discovered that another
3730              declaration of a global function with the same name already
3731              existed.
3732
3733              o Here, in duplicate_decls, we decided to clobber newdecl.
3734
3735              If we're going to do that, we'd better make sure that
3736              olddecl, and not newdecl, is on the list of
3737              instantiations so that if we try to do the instantiation
3738              again we won't get the clobbered declaration.  */
3739
3740           tree tmpl = DECL_TI_TEMPLATE (newdecl);
3741           tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3742
3743           for (; decls; decls = TREE_CHAIN (decls))
3744             if (TREE_VALUE (decls) == newdecl)
3745               TREE_VALUE (decls) = olddecl;
3746         }
3747     }
3748   else
3749     {
3750       bcopy ((char *) newdecl + sizeof (struct tree_common),
3751              (char *) olddecl + sizeof (struct tree_common),
3752              sizeof (struct tree_decl) - sizeof (struct tree_common)
3753              + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
3754     }
3755
3756   DECL_UID (olddecl) = olddecl_uid;
3757   if (olddecl_friend)
3758     DECL_FRIEND_P (olddecl) = 1;
3759
3760   /* NEWDECL contains the merged attribute lists.
3761      Update OLDDECL to be the same.  */
3762   DECL_MACHINE_ATTRIBUTES (olddecl) = DECL_MACHINE_ATTRIBUTES (newdecl);
3763
3764   return 1;
3765 }
3766
3767 /* Record a decl-node X as belonging to the current lexical scope.
3768    Check for errors (such as an incompatible declaration for the same
3769    name already seen in the same scope).
3770
3771    Returns either X or an old decl for the same name.
3772    If an old decl is returned, it may have been smashed
3773    to agree with what X says.  */
3774
3775 tree
3776 pushdecl (x)
3777      tree x;
3778 {
3779   register tree t;
3780   register tree name;
3781   int need_new_binding;
3782
3783   /* We shouldn't be calling pushdecl when we're generating RTL for a
3784      function that we already did semantic analysis on previously.  */
3785   my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3786                       19990913);
3787
3788   name = DECL_ASSEMBLER_NAME (x);
3789   need_new_binding = 1;
3790
3791   if (DECL_TEMPLATE_PARM_P (x))
3792     /* Template parameters have no context; they are not X::T even
3793        when declared within a class or namespace.  */
3794     ;
3795   else
3796     {
3797       if (current_function_decl && x != current_function_decl
3798           /* A local declaration for a function doesn't constitute
3799              nesting.  */
3800           && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3801           /* A local declaration for an `extern' variable is in the
3802              scoped of the current namespace, not the current
3803              function.  */
3804           && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3805           && !DECL_CONTEXT (x))
3806         DECL_CONTEXT (x) = current_function_decl;
3807       if (!DECL_CONTEXT (x))
3808         DECL_CONTEXT (x) = FROB_CONTEXT (current_namespace);
3809
3810       /* If this is the declaration for a namespace-scope function,
3811          but the declaration itself is in a local scope, mark the
3812          declaration.  */
3813       if (TREE_CODE (x) == FUNCTION_DECL
3814           && DECL_NAMESPACE_SCOPE_P (x)
3815           && current_function_decl
3816           && x != current_function_decl)
3817         DECL_LOCAL_FUNCTION_P (x) = 1;
3818     }
3819
3820   /* Type are looked up using the DECL_NAME, as that is what the rest of the
3821      compiler wants to use.  */
3822   if (TREE_CODE (x) == TYPE_DECL || TREE_CODE (x) == VAR_DECL
3823       || TREE_CODE (x) == NAMESPACE_DECL)
3824     name = DECL_NAME (x);
3825
3826   if (name)
3827     {
3828 #if 0
3829       /* Not needed...see below.  */
3830       char *file;
3831       int line;
3832 #endif
3833       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3834         name = TREE_OPERAND (name, 0);
3835
3836       /* Namespace-scoped variables are not found in the current level. */
3837       if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x))
3838         t = namespace_binding (name, DECL_CONTEXT (x));
3839       else
3840         t = lookup_name_current_level (name);
3841       if (t == error_mark_node)
3842         {
3843           /* error_mark_node is 0 for a while during initialization!  */
3844           t = NULL_TREE;
3845           cp_error_at ("`%#D' used prior to declaration", x);
3846         }
3847
3848       else if (t != NULL_TREE)
3849         {
3850 #if 0
3851           /* This is turned off until I have time to do it right (bpk).  */
3852           /* With the code below that uses it...  */
3853           file = DECL_SOURCE_FILE (t);
3854           line = DECL_SOURCE_LINE (t);
3855 #endif
3856           if (TREE_CODE (t) == PARM_DECL)
3857             {
3858               if (DECL_CONTEXT (t) == NULL_TREE)
3859                 fatal ("parse errors have confused me too much");
3860
3861               /* Check for duplicate params.  */
3862               if (duplicate_decls (x, t))
3863                 return t;
3864             }
3865           else if ((DECL_EXTERN_C_FUNCTION_P (x)
3866                     || DECL_FUNCTION_TEMPLATE_P (x))
3867                    && is_overloaded_fn (t))
3868             /* Don't do anything just yet. */;
3869           else if (t == wchar_decl_node)
3870             {
3871               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3872                 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x));
3873
3874               /* Throw away the redeclaration.  */
3875               return t;
3876             }
3877           else if (TREE_CODE (t) != TREE_CODE (x))
3878             {
3879               if (duplicate_decls (x, t))
3880                 return t;
3881             }
3882           else if (duplicate_decls (x, t))
3883             {
3884 #if 0
3885               /* This is turned off until I have time to do it right (bpk).  */
3886
3887               /* Also warn if they did a prototype with `static' on it, but
3888                  then later left the `static' off.  */
3889               if (! TREE_PUBLIC (name) && TREE_PUBLIC (x))
3890                 {
3891                   if (DECL_LANG_SPECIFIC (t) && DECL_FRIEND_P (t))
3892                     return t;
3893
3894                   if (extra_warnings)
3895                     {
3896                       cp_warning ("`static' missing from declaration of `%D'",
3897                                   t);
3898                       warning_with_file_and_line (file, line,
3899                                                   "previous declaration of `%s'",
3900                                                   decl_as_string (t, 0));
3901                     }
3902
3903                   /* Now fix things so it'll do what they expect.  */
3904                   if (current_function_decl)
3905                     TREE_PUBLIC (current_function_decl) = 0;
3906                 }
3907               /* Due to interference in memory reclamation (X may be
3908                  obstack-deallocated at this point), we must guard against
3909                  one really special case.  [jason: This should be handled
3910                  by start_function]  */
3911               if (current_function_decl == x)
3912                 current_function_decl = t;
3913 #endif
3914               if (TREE_CODE (t) == TYPE_DECL)
3915                 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3916               else if (TREE_CODE (t) == FUNCTION_DECL)
3917                 check_default_args (t);
3918
3919               return t;
3920             }
3921           else if (DECL_MAIN_P (x))
3922             {
3923               /* A redeclaration of main, but not a duplicate of the
3924                  previous one.
3925
3926                  [basic.start.main]
3927
3928                  This function shall not be overloaded.  */
3929               cp_error_at ("invalid redeclaration of `%D'", t);
3930               cp_error ("as `%D'", x);
3931               /* We don't try to push this declaration since that
3932                  causes a crash.  */
3933               return x;
3934             }
3935         }
3936
3937       check_template_shadow (x);
3938
3939       /* If this is a function conjured up by the backend, massage it
3940          so it looks friendly.  */
3941       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
3942         {
3943           retrofit_lang_decl (x);
3944           DECL_LANGUAGE (x) = lang_c;
3945         }
3946
3947       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
3948         {
3949           t = push_overloaded_decl (x, PUSH_LOCAL);
3950           if (t != x)
3951             return t;
3952           if (!namespace_bindings_p ())
3953             /* We do not need to create a binding for this name;
3954                push_overloaded_decl will have already done so if
3955                necessary.  */
3956             need_new_binding = 0;
3957         }
3958       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
3959         {
3960           t = push_overloaded_decl (x, PUSH_GLOBAL);
3961           if (t == x)
3962             add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
3963           return t;
3964         }
3965
3966       /* If declaring a type as a typedef, copy the type (unless we're
3967          at line 0), and install this TYPE_DECL as the new type's typedef
3968          name.  See the extensive comment in ../c-decl.c (pushdecl). */
3969       if (TREE_CODE (x) == TYPE_DECL)
3970         {
3971           tree type = TREE_TYPE (x);
3972           if (DECL_SOURCE_LINE (x) == 0)
3973             {
3974               if (TYPE_NAME (type) == 0)
3975                 TYPE_NAME (type) = x;
3976             }
3977           else if (type != error_mark_node && TYPE_NAME (type) != x
3978                    /* We don't want to copy the type when all we're
3979                       doing is making a TYPE_DECL for the purposes of
3980                       inlining.  */
3981                    && (!TYPE_NAME (type)
3982                        || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
3983             {
3984               DECL_ORIGINAL_TYPE (x) = type;
3985               type = build_type_copy (type);
3986               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
3987               TYPE_NAME (type) = x;
3988               TREE_TYPE (x) = type;
3989             }
3990
3991           if (type != error_mark_node
3992               && TYPE_NAME (type)
3993               && TYPE_IDENTIFIER (type))
3994             set_identifier_type_value_with_scope (DECL_NAME (x), type,
3995                                                   current_binding_level);
3996
3997         }
3998
3999       /* Multiple external decls of the same identifier ought to match.
4000
4001          We get warnings about inline functions where they are defined.
4002          We get warnings about other functions from push_overloaded_decl.
4003
4004          Avoid duplicate warnings where they are used.  */
4005       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
4006         {
4007           tree decl;
4008
4009           if (IDENTIFIER_NAMESPACE_VALUE (name) != NULL_TREE
4010               && (DECL_EXTERNAL (IDENTIFIER_NAMESPACE_VALUE (name))
4011                   || TREE_PUBLIC (IDENTIFIER_NAMESPACE_VALUE (name))))
4012             decl = IDENTIFIER_NAMESPACE_VALUE (name);
4013           else
4014             decl = NULL_TREE;
4015
4016           if (decl
4017               /* If different sort of thing, we already gave an error.  */
4018               && TREE_CODE (decl) == TREE_CODE (x)
4019               && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
4020             {
4021               cp_pedwarn ("type mismatch with previous external decl", x);
4022               cp_pedwarn_at ("previous external decl of `%#D'", decl);
4023             }
4024         }
4025
4026       /* This name is new in its binding level.
4027          Install the new declaration and return it.  */
4028       if (namespace_bindings_p ())
4029         {
4030           /* Install a global value.  */
4031
4032           /* If the first global decl has external linkage,
4033              warn if we later see static one.  */
4034           if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
4035             TREE_PUBLIC (name) = 1;
4036
4037           if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
4038                 && t != NULL_TREE)
4039               /* For an ordinary function, we create a binding from
4040                  the mangled name (i.e., NAME) to the DECL.  But, for
4041                  an `extern "C"' function, the mangled name and the
4042                  ordinary name are the same so we need not do this.  */
4043               && !DECL_EXTERN_C_FUNCTION_P (x))
4044             {
4045               if (TREE_CODE (x) == FUNCTION_DECL)
4046                 my_friendly_assert
4047                   ((IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE)
4048                   || (IDENTIFIER_GLOBAL_VALUE (name) == x), 378);
4049               SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
4050             }
4051
4052           /* Don't forget if the function was used via an implicit decl.  */
4053           if (IDENTIFIER_IMPLICIT_DECL (name)
4054               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
4055             TREE_USED (x) = 1;
4056
4057           /* Don't forget if its address was taken in that way.  */
4058           if (IDENTIFIER_IMPLICIT_DECL (name)
4059               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
4060             TREE_ADDRESSABLE (x) = 1;
4061
4062           /* Warn about mismatches against previous implicit decl.  */
4063           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
4064               /* If this real decl matches the implicit, don't complain.  */
4065               && ! (TREE_CODE (x) == FUNCTION_DECL
4066                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
4067             cp_warning
4068               ("`%D' was previously implicitly declared to return `int'", x);
4069
4070           /* If new decl is `static' and an `extern' was seen previously,
4071              warn about it.  */
4072           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
4073             warn_extern_redeclared_static (x, t);
4074         }
4075       else
4076         {
4077           /* Here to install a non-global value.  */
4078           tree oldlocal = IDENTIFIER_VALUE (name);
4079           tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
4080
4081           if (need_new_binding)
4082             {
4083               push_local_binding (name, x, 0);
4084               /* Because push_local_binding will hook X on to the
4085                  current_binding_level's name list, we don't want to
4086                  do that again below.  */
4087               need_new_binding = 0;
4088             }
4089
4090           /* If this is a TYPE_DECL, push it into the type value slot.  */
4091           if (TREE_CODE (x) == TYPE_DECL)
4092             set_identifier_type_value_with_scope (name, TREE_TYPE (x),
4093                                                   current_binding_level);
4094
4095           /* Clear out any TYPE_DECL shadowed by a namespace so that
4096              we won't think this is a type.  The C struct hack doesn't
4097              go through namespaces.  */
4098           if (TREE_CODE (x) == NAMESPACE_DECL)
4099             set_identifier_type_value_with_scope (name, NULL_TREE,
4100                                                   current_binding_level);
4101
4102           if (oldlocal)
4103             {
4104               tree d = oldlocal;
4105
4106               while (oldlocal
4107                      && TREE_CODE (oldlocal) == VAR_DECL
4108                      && DECL_DEAD_FOR_LOCAL (oldlocal))
4109                 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
4110
4111               if (oldlocal == NULL_TREE)
4112                 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
4113             }
4114
4115           /* If this is an extern function declaration, see if we
4116              have a global definition or declaration for the function.  */
4117           if (oldlocal == NULL_TREE
4118               && DECL_EXTERNAL (x)
4119               && oldglobal != NULL_TREE
4120               && TREE_CODE (x) == FUNCTION_DECL
4121               && TREE_CODE (oldglobal) == FUNCTION_DECL)
4122             {
4123               /* We have one.  Their types must agree.  */
4124               if (decls_match (x, oldglobal))
4125                 /* OK */;
4126               else
4127                 {
4128                   cp_warning ("extern declaration of `%#D' doesn't match", x);
4129                   cp_warning_at ("global declaration `%#D'", oldglobal);
4130                 }
4131             }
4132           /* If we have a local external declaration,
4133              and no file-scope declaration has yet been seen,
4134              then if we later have a file-scope decl it must not be static.  */
4135           if (oldlocal == NULL_TREE
4136               && oldglobal == NULL_TREE
4137               && DECL_EXTERNAL (x)
4138               && TREE_PUBLIC (x))
4139             TREE_PUBLIC (name) = 1;
4140
4141           /* Warn if shadowing an argument at the top level of the body.  */
4142           if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
4143               /* Inline decls shadow nothing.  */
4144               && !DECL_FROM_INLINE (x)
4145               && TREE_CODE (oldlocal) == PARM_DECL
4146               /* Don't complain if it's from an enclosing function.  */
4147               && DECL_CONTEXT (oldlocal) == current_function_decl
4148               && TREE_CODE (x) != PARM_DECL)
4149             {
4150               /* Go to where the parms should be and see if we
4151                  find them there.  */
4152               struct binding_level *b = current_binding_level->level_chain;
4153
4154               if (cleanup_label)
4155                 b = b->level_chain;
4156
4157               /* ARM $8.3 */
4158               if (b->parm_flag == 1)
4159                 cp_error ("declaration of `%#D' shadows a parameter", name);
4160             }
4161
4162           /* Maybe warn if shadowing something else.  */
4163           if (warn_shadow && !DECL_EXTERNAL (x)
4164               /* Inline decls shadow nothing.  */
4165               && !DECL_FROM_INLINE (x)
4166               /* No shadow warnings for internally generated vars.  */
4167               && ! DECL_ARTIFICIAL (x)
4168               /* No shadow warnings for vars made for inlining.  */
4169               && ! DECL_FROM_INLINE (x))
4170             {
4171               if (oldlocal != NULL_TREE && TREE_CODE (oldlocal) == PARM_DECL)
4172                 warning ("declaration of `%s' shadows a parameter",
4173                         IDENTIFIER_POINTER (name));
4174               else if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4175                        && current_class_ptr
4176                        && !TREE_STATIC (name))
4177                 warning ("declaration of `%s' shadows a member of `this'",
4178                         IDENTIFIER_POINTER (name));
4179               else if (oldlocal != NULL_TREE)
4180                 warning ("declaration of `%s' shadows previous local",
4181                         IDENTIFIER_POINTER (name));
4182               else if (oldglobal != NULL_TREE)
4183                 /* XXX shadow warnings in outer-more namespaces */
4184                 warning ("declaration of `%s' shadows global declaration",
4185                         IDENTIFIER_POINTER (name));
4186             }
4187         }
4188
4189       if (TREE_CODE (x) == FUNCTION_DECL)
4190         check_default_args (x);
4191
4192       /* Keep count of variables in this level with incomplete type.  */
4193       if (TREE_CODE (x) == VAR_DECL
4194           && TREE_TYPE (x) != error_mark_node
4195           && ((!COMPLETE_TYPE_P (TREE_TYPE (x))
4196                && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
4197               /* RTTI TD entries are created while defining the type_info.  */
4198               || (TYPE_LANG_SPECIFIC (TREE_TYPE (x))
4199                   && TYPE_BEING_DEFINED (TREE_TYPE (x)))))
4200         {
4201           if (namespace_bindings_p ())
4202             namespace_scope_incomplete
4203               = tree_cons (NULL_TREE, x, namespace_scope_incomplete);
4204           else
4205             current_binding_level->incomplete
4206               = tree_cons (NULL_TREE, x, current_binding_level->incomplete);
4207         }
4208     }
4209
4210   if (need_new_binding)
4211     add_decl_to_level (x,
4212                        DECL_NAMESPACE_SCOPE_P (x)
4213                        ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4214                        : current_binding_level);
4215
4216   return x;
4217 }
4218
4219 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
4220    caller to set DECL_CONTEXT properly.  */
4221
4222 static tree
4223 pushdecl_with_scope (x, level)
4224      tree x;
4225      struct binding_level *level;
4226 {
4227   register struct binding_level *b;
4228   tree function_decl = current_function_decl;
4229
4230   current_function_decl = NULL_TREE;
4231   if (level->parm_flag == 2)
4232     {
4233       b = class_binding_level;
4234       class_binding_level = level;
4235       pushdecl_class_level (x);
4236       class_binding_level = b;
4237     }
4238   else
4239     {
4240       b = current_binding_level;
4241       current_binding_level = level;
4242       x = pushdecl (x);
4243       current_binding_level = b;
4244     }
4245   current_function_decl = function_decl;
4246   return x;
4247 }
4248
4249 /* Like pushdecl, only it places X in the current namespace,
4250    if appropriate.  */
4251
4252 tree
4253 pushdecl_namespace_level (x)
4254      tree x;
4255 {
4256   register struct binding_level *b = current_binding_level;
4257   register tree t;
4258
4259   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4260
4261   /* Now, the type_shadowed stack may screw us.  Munge it so it does
4262      what we want.  */
4263   if (TREE_CODE (x) == TYPE_DECL)
4264     {
4265       tree name = DECL_NAME (x);
4266       tree newval;
4267       tree *ptr = (tree *)0;
4268       for (; b != global_binding_level; b = b->level_chain)
4269         {
4270           tree shadowed = b->type_shadowed;
4271           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4272             if (TREE_PURPOSE (shadowed) == name)
4273               {
4274                 ptr = &TREE_VALUE (shadowed);
4275                 /* Can't break out of the loop here because sometimes
4276                    a binding level will have duplicate bindings for
4277                    PT names.  It's gross, but I haven't time to fix it.  */
4278               }
4279         }
4280       newval = TREE_TYPE (x);
4281       if (ptr == (tree *)0)
4282         {
4283           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
4284              up here if this is changed to an assertion.  --KR  */
4285           SET_IDENTIFIER_TYPE_VALUE (name, newval);
4286         }
4287       else
4288         {
4289           *ptr = newval;
4290         }
4291     }
4292   return t;
4293 }
4294
4295 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4296    if appropriate.  */
4297
4298 tree
4299 pushdecl_top_level (x)
4300      tree x;
4301 {
4302   push_to_top_level ();
4303   x = pushdecl_namespace_level (x);
4304   pop_from_top_level ();
4305   return x;
4306 }
4307
4308 /* Make the declaration of X appear in CLASS scope.  */
4309
4310 void
4311 pushdecl_class_level (x)
4312      tree x;
4313 {
4314   /* Don't use DECL_ASSEMBLER_NAME here!  Everything that looks in class
4315      scope looks for the pre-mangled name.  */
4316   register tree name;
4317
4318   if (TREE_CODE (x) == OVERLOAD)
4319     x = OVL_CURRENT (x);
4320   name = DECL_NAME (x);
4321
4322   if (name)
4323     {
4324       push_class_level_binding (name, x);
4325       if (TREE_CODE (x) == TYPE_DECL)
4326         set_identifier_type_value (name, TREE_TYPE (x));
4327     }
4328   else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4329     {
4330       tree f;
4331
4332       for (f = TYPE_FIELDS (TREE_TYPE (x));
4333            f;
4334            f = TREE_CHAIN (f))
4335         pushdecl_class_level (f);
4336     }
4337 }
4338
4339 /* Enter DECL into the symbol table, if that's appropriate.  Returns
4340    DECL, or a modified version thereof.  */
4341
4342 tree
4343 maybe_push_decl (decl)
4344      tree decl;
4345 {
4346   tree type = TREE_TYPE (decl);
4347
4348   /* Add this decl to the current binding level, but not if it comes
4349      from another scope, e.g. a static member variable.  TEM may equal
4350      DECL or it may be a previous decl of the same name.  */
4351   if (decl == error_mark_node
4352       || (TREE_CODE (decl) != PARM_DECL
4353           && DECL_CONTEXT (decl) != NULL_TREE
4354           /* Definitions of namespace members outside their namespace are
4355              possible. */
4356           && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4357       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4358       || TREE_CODE (type) == UNKNOWN_TYPE
4359       /* The declaration of a template specialization does not affect
4360          the functions available for overload resolution, so we do not
4361          call pushdecl.  */
4362       || (TREE_CODE (decl) == FUNCTION_DECL
4363           && DECL_TEMPLATE_SPECIALIZATION (decl)))
4364     return decl;
4365   else
4366     return pushdecl (decl);
4367 }
4368
4369 /* Make the declaration(s) of X appear in CLASS scope
4370    under the name NAME.  */
4371
4372 void
4373 push_class_level_binding (name, x)
4374      tree name;
4375      tree x;
4376 {
4377   tree binding;
4378   /* The class_binding_level will be NULL if x is a template
4379      parameter name in a member template.  */
4380   if (!class_binding_level)
4381     return;
4382
4383   /* Make sure that this new member does not have the same name
4384      as a template parameter.  */
4385   if (TYPE_BEING_DEFINED (current_class_type))
4386     check_template_shadow (x);
4387
4388   /* If this declaration shadows a declaration from an enclosing
4389      class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4390      we leave this class.  Record the shadowed declaration here.  */
4391   binding = IDENTIFIER_BINDING (name);
4392   if (binding
4393       && ((TREE_CODE (x) == OVERLOAD
4394            && BINDING_VALUE (binding)
4395            && is_overloaded_fn (BINDING_VALUE (binding)))
4396           || INHERITED_VALUE_BINDING_P (binding)))
4397     {
4398       tree shadow;
4399       tree old_decl;
4400
4401       /* If the old binding was from a base class, and was for a tag
4402          name, slide it over to make room for the new binding.  The
4403          old binding is still visible if explicitly qualified with a
4404          class-key.  */
4405       if (INHERITED_VALUE_BINDING_P (binding)
4406           && BINDING_VALUE (binding)
4407           && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4408           && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4409           && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4410         {
4411           old_decl = BINDING_TYPE (binding);
4412           BINDING_TYPE (binding) = BINDING_VALUE (binding);
4413           BINDING_VALUE (binding) = NULL_TREE;
4414           INHERITED_VALUE_BINDING_P (binding) = 0;
4415         }
4416       else
4417         old_decl = BINDING_VALUE (binding);
4418
4419       /* There was already a binding for X containing fewer
4420          functions than are named in X.  Find the previous
4421          declaration of X on the class-shadowed list, and update it.  */
4422       for (shadow = class_binding_level->class_shadowed;
4423            shadow;
4424            shadow = TREE_CHAIN (shadow))
4425         if (TREE_PURPOSE (shadow) == name
4426             && TREE_TYPE (shadow) == old_decl)
4427           {
4428             BINDING_VALUE (binding) = x;
4429             INHERITED_VALUE_BINDING_P (binding) = 0;
4430             TREE_TYPE (shadow) = x;
4431             return;
4432           }
4433     }
4434
4435   /* If we didn't replace an existing binding, put the binding on the
4436      stack of bindings for the identifier, and update
4437      IDENTIFIER_CLASS_VALUE.  */
4438   if (push_class_binding (name, x))
4439     {
4440       class_binding_level->class_shadowed
4441         = tree_cons (name, IDENTIFIER_CLASS_VALUE (name),
4442                      class_binding_level->class_shadowed);
4443       /* Record the value we are binding NAME to so that we can know
4444          what to pop later.  */
4445       TREE_TYPE (class_binding_level->class_shadowed) = x;
4446     }
4447 }
4448
4449 /* Insert another USING_DECL into the current binding level, returning
4450    this declaration. If this is a redeclaration, do nothing, and
4451    return NULL_TREE if this not in namespace scope (in namespace
4452    scope, a using decl might extend any previous bindings).  */
4453
4454 tree
4455 push_using_decl (scope, name)
4456      tree scope;
4457      tree name;
4458 {
4459   tree decl;
4460
4461   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4462   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4463   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4464     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4465       break;
4466   if (decl)
4467     return namespace_bindings_p () ? decl : NULL_TREE;
4468   decl = build_lang_decl (USING_DECL, name, void_type_node);
4469   DECL_INITIAL (decl) = scope;
4470   TREE_CHAIN (decl) = current_binding_level->usings;
4471   current_binding_level->usings = decl;
4472   return decl;
4473 }
4474
4475 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4476    changed (i.e. there was already a directive), or the fresh
4477    TREE_LIST otherwise.  */
4478
4479 tree
4480 push_using_directive (used)
4481      tree used;
4482 {
4483   tree ud = current_binding_level->using_directives;
4484   tree iter, ancestor;
4485
4486   /* Check if we already have this. */
4487   if (purpose_member (used, ud) != NULL_TREE)
4488     return NULL_TREE;
4489
4490   /* Recursively add all namespaces used. */
4491   for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4492     push_using_directive (TREE_PURPOSE (iter));
4493
4494   ancestor = namespace_ancestor (current_decl_namespace (), used);
4495   ud = current_binding_level->using_directives;
4496   ud = tree_cons (used, ancestor, ud);
4497   current_binding_level->using_directives = ud;
4498   return ud;
4499 }
4500
4501 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4502    other definitions already in place.  We get around this by making
4503    the value of the identifier point to a list of all the things that
4504    want to be referenced by that name.  It is then up to the users of
4505    that name to decide what to do with that list.
4506
4507    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
4508    DECL_TEMPLATE_RESULT.  It is dealt with the same way.
4509
4510    FLAGS is a bitwise-or of the following values:
4511      PUSH_LOCAL: Bind DECL in the current scope, rather than at
4512                  namespace scope.
4513      PUSH_USING: DECL is being pushed as the result of a using
4514                  declaration.
4515
4516    The value returned may be a previous declaration if we guessed wrong
4517    about what language DECL should belong to (C or C++).  Otherwise,
4518    it's always DECL (and never something that's not a _DECL).  */
4519
4520 tree
4521 push_overloaded_decl (decl, flags)
4522      tree decl;
4523      int flags;
4524 {
4525   tree name = DECL_NAME (decl);
4526   tree old;
4527   tree new_binding;
4528   int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4529
4530   if (doing_global)
4531     old = namespace_binding (name, DECL_CONTEXT (decl));
4532   else
4533     old = lookup_name_current_level (name);
4534
4535   if (old)
4536     {
4537       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4538         {
4539           tree t = TREE_TYPE (old);
4540           if (IS_AGGR_TYPE (t) && warn_shadow
4541               && (! DECL_IN_SYSTEM_HEADER (decl)
4542                   || ! DECL_IN_SYSTEM_HEADER (old)))
4543             cp_warning ("`%#D' hides constructor for `%#T'", decl, t);
4544           old = NULL_TREE;
4545         }
4546       else if (is_overloaded_fn (old))
4547         {
4548           tree tmp;
4549
4550           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4551             {
4552               tree fn = OVL_CURRENT (tmp);
4553
4554               if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4555                   && !(flags & PUSH_USING)
4556                   && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4557                                 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4558                 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4559                           decl, fn);
4560
4561               if (duplicate_decls (decl, fn))
4562                 return fn;
4563             }
4564         }
4565       else
4566         {
4567           cp_error_at ("previous non-function declaration `%#D'", old);
4568           cp_error ("conflicts with function declaration `%#D'", decl);
4569           return decl;
4570         }
4571     }
4572
4573   if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4574     {
4575       if (old && TREE_CODE (old) != OVERLOAD)
4576         new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4577       else
4578         new_binding = ovl_cons (decl, old);
4579       if (flags & PUSH_USING)
4580         OVL_USED (new_binding) = 1;
4581     }
4582   else
4583     /* NAME is not ambiguous.  */
4584     new_binding = decl;
4585
4586   if (doing_global)
4587     set_namespace_binding (name, current_namespace, new_binding);
4588   else
4589     {
4590       /* We only create an OVERLOAD if there was a previous binding at
4591          this level, or if decl is a template. In the former case, we
4592          need to remove the old binding and replace it with the new
4593          binding.  We must also run through the NAMES on the binding
4594          level where the name was bound to update the chain.  */
4595
4596       if (TREE_CODE (new_binding) == OVERLOAD && old)
4597         {
4598           tree *d;
4599
4600           for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4601                *d;
4602                d = &TREE_CHAIN (*d))
4603             if (*d == old
4604                 || (TREE_CODE (*d) == TREE_LIST
4605                     && TREE_VALUE (*d) == old))
4606               {
4607                 if (TREE_CODE (*d) == TREE_LIST)
4608                   /* Just replace the old binding with the new.  */
4609                   TREE_VALUE (*d) = new_binding;
4610                 else
4611                   /* Build a TREE_LIST to wrap the OVERLOAD.  */
4612                   *d = tree_cons (NULL_TREE, new_binding,
4613                                   TREE_CHAIN (*d));
4614
4615                 /* And update the CPLUS_BINDING node.  */
4616                 BINDING_VALUE (IDENTIFIER_BINDING (name))
4617                   = new_binding;
4618                 return decl;
4619               }
4620
4621           /* We should always find a previous binding in this case.  */
4622           my_friendly_abort (0);
4623         }
4624
4625       /* Install the new binding.  */
4626       push_local_binding (name, new_binding, flags);
4627     }
4628
4629   return decl;
4630 }
4631 \f
4632 /* Generate an implicit declaration for identifier FUNCTIONID
4633    as a function of type int ().  Print a warning if appropriate.  */
4634
4635 tree
4636 implicitly_declare (functionid)
4637      tree functionid;
4638 {
4639   register tree decl;
4640
4641   /* We used to reuse an old implicit decl here,
4642      but this loses with inline functions because it can clobber
4643      the saved decl chains.  */
4644   decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4645
4646   DECL_EXTERNAL (decl) = 1;
4647   TREE_PUBLIC (decl) = 1;
4648
4649   /* ISO standard says implicit declarations are in the innermost block.
4650      So we record the decl in the standard fashion.  */
4651   pushdecl (decl);
4652   rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
4653
4654   if (warn_implicit
4655       /* Only one warning per identifier.  */
4656       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4657     {
4658       cp_pedwarn ("implicit declaration of function `%#D'", decl);
4659     }
4660
4661   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4662
4663   return decl;
4664 }
4665
4666 /* Return zero if the declaration NEWDECL is valid
4667    when the declaration OLDDECL (assumed to be for the same name)
4668    has already been seen.
4669    Otherwise return an error message format string with a %s
4670    where the identifier should go.  */
4671
4672 static const char *
4673 redeclaration_error_message (newdecl, olddecl)
4674      tree newdecl, olddecl;
4675 {
4676   if (TREE_CODE (newdecl) == TYPE_DECL)
4677     {
4678       /* Because C++ can put things into name space for free,
4679          constructs like "typedef struct foo { ... } foo"
4680          would look like an erroneous redeclaration.  */
4681       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4682         return 0;
4683       else
4684         return "redefinition of `%#D'";
4685     }
4686   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4687     {
4688       /* If this is a pure function, its olddecl will actually be
4689          the original initialization to `0' (which we force to call
4690          abort()).  Don't complain about redefinition in this case.  */
4691       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4692         return 0;
4693
4694       /* If both functions come from different namespaces, this is not
4695          a redeclaration - this is a conflict with a used function. */
4696       if (DECL_NAMESPACE_SCOPE_P (olddecl)
4697           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4698         return "`%D' conflicts with used function";
4699
4700       /* We'll complain about linkage mismatches in
4701          warn_extern_redeclared_static.  */
4702
4703       /* Defining the same name twice is no good.  */
4704       if (DECL_INITIAL (olddecl) != NULL_TREE
4705           && DECL_INITIAL (newdecl) != NULL_TREE)
4706         {
4707           if (DECL_NAME (olddecl) == NULL_TREE)
4708             return "`%#D' not declared in class";
4709           else
4710             return "redefinition of `%#D'";
4711         }
4712       return 0;
4713     }
4714   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4715     {
4716       if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4717            && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4718            && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4719           || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4720               && COMPLETE_TYPE_P (TREE_TYPE (newdecl))
4721               && COMPLETE_TYPE_P (TREE_TYPE (olddecl))))
4722         return "redefinition of `%#D'";
4723       return 0;
4724     }
4725   else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
4726     {
4727       /* Objects declared at top level:  */
4728       /* If at least one is a reference, it's ok.  */
4729       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4730         return 0;
4731       /* Reject two definitions.  */
4732       return "redefinition of `%#D'";
4733     }
4734   else
4735     {
4736       /* Objects declared with block scope:  */
4737       /* Reject two definitions, and reject a definition
4738          together with an external reference.  */
4739       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4740         return "redeclaration of `%#D'";
4741       return 0;
4742     }
4743 }
4744 \f
4745 /* Create a new label, named ID.  */
4746
4747 static tree
4748 make_label_decl (id, local_p)
4749      tree id;
4750      int local_p;
4751 {
4752   tree decl;
4753
4754   decl = build_decl (LABEL_DECL, id, void_type_node);
4755   if (expanding_p)
4756     /* Make sure every label has an rtx.  */
4757     label_rtx (decl);
4758
4759   DECL_CONTEXT (decl) = current_function_decl;
4760   DECL_MODE (decl) = VOIDmode;
4761   C_DECLARED_LABEL_FLAG (decl) = local_p;
4762
4763   /* Say where one reference is to the label, for the sake of the
4764      error if it is not defined.  */
4765   DECL_SOURCE_LINE (decl) = lineno;
4766   DECL_SOURCE_FILE (decl) = input_filename;
4767
4768   /* Record the fact that this identifier is bound to this label.  */
4769   SET_IDENTIFIER_LABEL_VALUE (id, decl);
4770
4771   return decl;
4772 }
4773
4774 /* Record this label on the list of used labels so that we can check
4775    at the end of the function to see whether or not the label was
4776    actually defined, and so we can check when the label is defined whether
4777    this use is valid.  */
4778
4779 static void
4780 use_label (decl)
4781      tree decl;
4782 {
4783   if (named_label_uses == NULL
4784       || named_label_uses->names_in_scope != current_binding_level->names
4785       || named_label_uses->label_decl != decl)
4786     {
4787       struct named_label_use_list *new_ent;
4788       new_ent = ((struct named_label_use_list *)
4789                  ggc_alloc (sizeof (struct named_label_use_list)));
4790       new_ent->label_decl = decl;
4791       new_ent->names_in_scope = current_binding_level->names;
4792       new_ent->binding_level = current_binding_level;
4793       new_ent->lineno_o_goto = lineno;
4794       new_ent->filename_o_goto = input_filename;
4795       new_ent->next = named_label_uses;
4796       named_label_uses = new_ent;
4797     }
4798 }
4799
4800 /* Look for a label named ID in the current function.  If one cannot
4801    be found, create one.  (We keep track of used, but undefined,
4802    labels, and complain about them at the end of a function.)  */
4803
4804 tree
4805 lookup_label (id)
4806      tree id;
4807 {
4808   tree decl;
4809   struct named_label_list *ent;
4810
4811   /* You can't use labels at global scope.  */
4812   if (current_function_decl == NULL_TREE)
4813     {
4814       error ("label `%s' referenced outside of any function",
4815              IDENTIFIER_POINTER (id));
4816       return NULL_TREE;
4817     }
4818
4819   /* See if we've already got this label.  */
4820   decl = IDENTIFIER_LABEL_VALUE (id);
4821   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4822     return decl;
4823
4824   /* Record this label on the list of labels used in this function.
4825      We do this before calling make_label_decl so that we get the
4826      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
4827   ent = ((struct named_label_list *)
4828          ggc_alloc_obj (sizeof (struct named_label_list), 1));
4829   ent->old_value = IDENTIFIER_LABEL_VALUE (id);
4830   ent->next = named_labels;
4831   named_labels = ent;
4832
4833   /* We need a new label.  */
4834   decl = make_label_decl (id, /*local_p=*/0);
4835
4836   /* Now fill in the information we didn't have before.  */
4837   ent->label_decl = decl;
4838
4839   return decl;
4840 }
4841
4842 /* Declare a local label named ID.  */
4843
4844 tree
4845 declare_local_label (id)
4846      tree id;
4847 {
4848   tree decl;
4849
4850   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4851      this scope we can restore the old value of
4852      IDENTIFIER_TYPE_VALUE.  */
4853   current_binding_level->shadowed_labels
4854     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4855                  current_binding_level->shadowed_labels);
4856   /* Look for the label.  */
4857   decl = make_label_decl (id, /*local_p=*/1);
4858   /* Now fill in the information we didn't have before.  */
4859   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4860
4861   return decl;
4862 }
4863
4864 /* Returns nonzero if it is ill-formed to jump past the declaration of
4865    DECL.  Returns 2 if it's also a real problem.  */
4866
4867 static int
4868 decl_jump_unsafe (decl)
4869      tree decl;
4870 {
4871   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
4872     return 0;
4873
4874   if (DECL_INITIAL (decl) == NULL_TREE
4875       && pod_type_p (TREE_TYPE (decl)))
4876     return 0;
4877
4878   /* This is really only important if we're crossing an initialization.
4879      The POD stuff is just pedantry; why should it matter if the class
4880      contains a field of pointer to member type?  */
4881   if (DECL_INITIAL (decl)
4882       || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
4883     return 2;
4884   return 1;
4885 }
4886
4887 /* Check that a single previously seen jump to a newly defined label
4888    is OK.  DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
4889    the jump context; NAMES are the names in scope in LEVEL at the jump
4890    context; FILE and LINE are the source position of the jump or 0.  */
4891
4892 static void
4893 check_previous_goto_1 (decl, level, names, file, line)
4894      tree decl;
4895      struct binding_level *level;
4896      tree names;
4897      const char *file;
4898      int line;
4899 {
4900   int identified = 0;
4901   int saw_eh = 0;
4902   struct binding_level *b = current_binding_level;
4903   for (; b; b = b->level_chain)
4904     {
4905       tree new_decls = b->names;
4906       tree old_decls = (b == level ? names : NULL_TREE);
4907       for (; new_decls != old_decls;
4908            new_decls = TREE_CHAIN (new_decls))
4909         {
4910           int problem = decl_jump_unsafe (new_decls);
4911           if (! problem)
4912             continue;
4913
4914           if (! identified)
4915             {
4916               if (decl)
4917                 cp_pedwarn ("jump to label `%D'", decl);
4918               else
4919                 pedwarn ("jump to case label");
4920
4921               if (file)
4922                 pedwarn_with_file_and_line (file, line, "  from here");
4923               identified = 1;
4924             }
4925
4926           if (problem > 1 && DECL_ARTIFICIAL (new_decls))
4927             /* Can't skip init of __exception_info.  */
4928             cp_error_at ("  enters catch block", new_decls);
4929           else if (problem > 1)
4930             cp_error_at ("  crosses initialization of `%#D'",
4931                          new_decls);
4932           else
4933             cp_pedwarn_at ("  enters scope of non-POD `%#D'",
4934                            new_decls);
4935         }
4936
4937       if (b == level)
4938         break;
4939       if (b->eh_region && ! saw_eh)
4940         {
4941           if (! identified)
4942             {
4943               if (decl)
4944                 cp_pedwarn ("jump to label `%D'", decl);
4945               else
4946                 pedwarn ("jump to case label");
4947
4948               if (file)
4949                 pedwarn_with_file_and_line (file, line, "  from here");
4950               identified = 1;
4951             }
4952           error ("  enters try block");
4953           saw_eh = 1;
4954         }
4955     }
4956 }
4957
4958 static void
4959 check_previous_goto (use)
4960      struct named_label_use_list *use;
4961 {
4962   check_previous_goto_1 (use->label_decl, use->binding_level,
4963                          use->names_in_scope, use->filename_o_goto,
4964                          use->lineno_o_goto);
4965 }
4966
4967 static void
4968 check_switch_goto (level)
4969      struct binding_level *level;
4970 {
4971   check_previous_goto_1 (NULL_TREE, level, level->names, NULL, 0);
4972 }
4973
4974 /* Check that any previously seen jumps to a newly defined label DECL
4975    are OK.  Called by define_label.  */
4976
4977 static void
4978 check_previous_gotos (decl)
4979      tree decl;
4980 {
4981   struct named_label_use_list **usep;
4982
4983   if (! TREE_USED (decl))
4984     return;
4985
4986   for (usep = &named_label_uses; *usep; )
4987     {
4988       struct named_label_use_list *use = *usep;
4989       if (use->label_decl == decl)
4990         {
4991           check_previous_goto (use);
4992           *usep = use->next;
4993         }
4994       else
4995         usep = &(use->next);
4996     }
4997 }
4998
4999 /* Check that a new jump to a label DECL is OK.  Called by
5000    finish_goto_stmt.  */
5001
5002 void
5003 check_goto (decl)
5004      tree decl;
5005 {
5006   int identified = 0;
5007   tree bad;
5008   struct named_label_list *lab;
5009
5010   /* If the label hasn't been defined yet, defer checking.  */
5011   if (! DECL_INITIAL (decl))
5012     {
5013       use_label (decl);
5014       return;
5015     }
5016
5017   for (lab = named_labels; lab; lab = lab->next)
5018     if (decl == lab->label_decl)
5019       break;
5020
5021   /* If the label is not on named_labels it's a gcc local label, so
5022      it must be in an outer scope, so jumping to it is always OK.  */
5023   if (lab == 0)
5024     return;
5025
5026   if ((lab->eh_region || lab->bad_decls) && !identified)
5027     {
5028       cp_pedwarn_at ("jump to label `%D'", decl);
5029       pedwarn ("  from here");
5030       identified = 1;
5031     }
5032
5033   for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad))
5034     {
5035       tree b = TREE_VALUE (bad);
5036       int u = decl_jump_unsafe (b);
5037
5038       if (u > 1 && DECL_ARTIFICIAL (b))
5039         /* Can't skip init of __exception_info.  */
5040         cp_error_at ("  enters catch block", b);
5041       else if (u > 1)
5042         cp_error_at ("  skips initialization of `%#D'", b);
5043       else
5044         cp_pedwarn_at ("  enters scope of non-POD `%#D'", b);
5045     }
5046
5047   if (lab->eh_region)
5048     error ("  enters try block");
5049 }
5050
5051 /* Define a label, specifying the location in the source file.
5052    Return the LABEL_DECL node for the label, if the definition is valid.
5053    Otherwise return 0.  */
5054
5055 tree
5056 define_label (filename, line, name)
5057      const char *filename;
5058      int line;
5059      tree name;
5060 {
5061   tree decl = lookup_label (name);
5062   struct named_label_list *ent;
5063
5064   for (ent = named_labels; ent; ent = ent->next)
5065     if (ent->label_decl == decl)
5066       break;
5067
5068   /* After labels, make any new cleanups go into their
5069      own new (temporary) binding contour.  */
5070   current_binding_level->more_cleanups_ok = 0;
5071
5072   if (name == get_identifier ("wchar_t"))
5073     cp_pedwarn ("label named wchar_t");
5074
5075   if (DECL_INITIAL (decl) != NULL_TREE)
5076     {
5077       cp_error ("duplicate label `%D'", decl);
5078       return 0;
5079     }
5080   else
5081     {
5082       /* Mark label as having been defined.  */
5083       DECL_INITIAL (decl) = error_mark_node;
5084       /* Say where in the source.  */
5085       DECL_SOURCE_FILE (decl) = filename;
5086       DECL_SOURCE_LINE (decl) = line;
5087       if (ent)
5088         {
5089           ent->names_in_scope = current_binding_level->names;
5090           ent->binding_level = current_binding_level;
5091         }
5092       check_previous_gotos (decl);
5093       current_function_return_value = NULL_TREE;
5094       return decl;
5095     }
5096 }
5097
5098 struct cp_switch
5099 {
5100   struct binding_level *level;
5101   struct cp_switch *next;
5102 };
5103
5104 static struct cp_switch *switch_stack;
5105
5106 void
5107 push_switch ()
5108 {
5109   struct cp_switch *p
5110     = (struct cp_switch *) xmalloc (sizeof (struct cp_switch));
5111   p->level = current_binding_level;
5112   p->next = switch_stack;
5113   switch_stack = p;
5114 }
5115
5116 void
5117 pop_switch ()
5118 {
5119   struct cp_switch *cs;
5120
5121   cs = switch_stack;
5122   switch_stack = switch_stack->next;
5123   free (cs);
5124 }
5125
5126 /* Note that we've seen a definition of a case label, and complain if this
5127    is a bad place for one.  */
5128
5129 void
5130 define_case_label ()
5131 {
5132   tree cleanup = last_cleanup_this_contour ();
5133
5134   if (! switch_stack)
5135     /* Don't crash; we'll complain in do_case.  */
5136     return;
5137
5138   if (cleanup)
5139     {
5140       static int explained = 0;
5141       cp_warning_at ("destructor needed for `%#D'", TREE_PURPOSE (cleanup));
5142       warning ("where case label appears here");
5143       if (!explained)
5144         {
5145           warning ("(enclose actions of previous case statements requiring");
5146           warning ("destructors in their own binding contours.)");
5147           explained = 1;
5148         }
5149     }
5150
5151   check_switch_goto (switch_stack->level);
5152
5153   /* After labels, make any new cleanups go into their
5154      own new (temporary) binding contour.  */
5155
5156   current_binding_level->more_cleanups_ok = 0;
5157   current_function_return_value = NULL_TREE;
5158 }
5159 \f
5160 /* Return the list of declarations of the current level.
5161    Note that this list is in reverse order unless/until
5162    you nreverse it; and when you do nreverse it, you must
5163    store the result back using `storedecls' or you will lose.  */
5164
5165 tree
5166 getdecls ()
5167 {
5168   return current_binding_level->names;
5169 }
5170
5171 /* Return the list of type-tags (for structs, etc) of the current level.  */
5172
5173 tree
5174 gettags ()
5175 {
5176   return current_binding_level->tags;
5177 }
5178
5179 /* Store the list of declarations of the current level.
5180    This is done for the parameter declarations of a function being defined,
5181    after they are modified in the light of any missing parameters.  */
5182
5183 static void
5184 storedecls (decls)
5185      tree decls;
5186 {
5187   current_binding_level->names = decls;
5188 }
5189
5190 /* Similarly, store the list of tags of the current level.  */
5191
5192 void
5193 storetags (tags)
5194      tree tags;
5195 {
5196   current_binding_level->tags = tags;
5197 }
5198 \f
5199 /* Given NAME, an IDENTIFIER_NODE,
5200    return the structure (or union or enum) definition for that name.
5201    Searches binding levels from BINDING_LEVEL up to the global level.
5202    If THISLEVEL_ONLY is nonzero, searches only the specified context
5203    (but skips any tag-transparent contexts to find one that is
5204    meaningful for tags).
5205    FORM says which kind of type the caller wants;
5206    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5207    If the wrong kind of type is found, and it's not a template, an error is
5208    reported.  */
5209
5210 static tree
5211 lookup_tag (form, name, binding_level, thislevel_only)
5212      enum tree_code form;
5213      tree name;
5214      struct binding_level *binding_level;
5215      int thislevel_only;
5216 {
5217   register struct binding_level *level;
5218   /* Non-zero if, we should look past a template parameter level, even
5219      if THISLEVEL_ONLY.  */
5220   int allow_template_parms_p = 1;
5221
5222   for (level = binding_level; level; level = level->level_chain)
5223     {
5224       register tree tail;
5225       if (ANON_AGGRNAME_P (name))
5226         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5227           {
5228             /* There's no need for error checking here, because
5229                anon names are unique throughout the compilation.  */
5230             if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
5231               return TREE_VALUE (tail);
5232           }
5233       else if (level->namespace_p)
5234         /* Do namespace lookup. */
5235         for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
5236           {
5237             tree old = binding_for_name (name, tail);
5238
5239             /* If we just skipped past a template parameter level,
5240                even though THISLEVEL_ONLY, and we find a template
5241                class declaration, then we use the _TYPE node for the
5242                template.  See the example below.  */
5243             if (thislevel_only && !allow_template_parms_p
5244                 && old && BINDING_VALUE (old)
5245                 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
5246               old = TREE_TYPE (BINDING_VALUE (old));
5247             else
5248               old = BINDING_TYPE (old);
5249
5250             /* If it has an original type, it is a typedef, and we
5251                should not return it.  */
5252             if (old && DECL_ORIGINAL_TYPE (TYPE_NAME (old)))
5253               old = NULL_TREE;
5254             if (old && TREE_CODE (old) != form
5255                 && !(form != ENUMERAL_TYPE && TREE_CODE (old) == TEMPLATE_DECL))
5256               {
5257                 cp_error ("`%#D' redeclared as %C", old, form);
5258                 return NULL_TREE;
5259               }
5260             if (old)
5261               return old;
5262             if (thislevel_only || tail == global_namespace)
5263               return NULL_TREE;
5264           }
5265       else
5266         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5267           {
5268             if (TREE_PURPOSE (tail) == name)
5269               {
5270                 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5271                 /* Should tighten this up; it'll probably permit
5272                    UNION_TYPE and a struct template, for example.  */
5273                 if (code != form
5274                     && !(form != ENUMERAL_TYPE && code == TEMPLATE_DECL))
5275                   {
5276                     /* Definition isn't the kind we were looking for.  */
5277                     cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
5278                               form);
5279                     return NULL_TREE;
5280                   }
5281                 return TREE_VALUE (tail);
5282               }
5283           }
5284       if (thislevel_only && ! level->tag_transparent)
5285         {
5286           if (level->template_parms_p && allow_template_parms_p)
5287             {
5288               /* We must deal with cases like this:
5289
5290                    template <class T> struct S;
5291                    template <class T> struct S {};
5292
5293                  When looking up `S', for the second declaration, we
5294                  would like to find the first declaration.  But, we
5295                  are in the pseudo-global level created for the
5296                  template parameters, rather than the (surrounding)
5297                  namespace level.  Thus, we keep going one more level,
5298                  even though THISLEVEL_ONLY is non-zero.  */
5299               allow_template_parms_p = 0;
5300               continue;
5301             }
5302           else
5303             return NULL_TREE;
5304         }
5305     }
5306   return NULL_TREE;
5307 }
5308
5309 #if 0
5310 void
5311 set_current_level_tags_transparency (tags_transparent)
5312      int tags_transparent;
5313 {
5314   current_binding_level->tag_transparent = tags_transparent;
5315 }
5316 #endif
5317
5318 /* Given a type, find the tag that was defined for it and return the tag name.
5319    Otherwise return 0.  However, the value can never be 0
5320    in the cases in which this is used.
5321
5322    C++: If NAME is non-zero, this is the new name to install.  This is
5323    done when replacing anonymous tags with real tag names.  */
5324
5325 static tree
5326 lookup_tag_reverse (type, name)
5327      tree type;
5328      tree name;
5329 {
5330   register struct binding_level *level;
5331
5332   for (level = current_binding_level; level; level = level->level_chain)
5333     {
5334       register tree tail;
5335       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5336         {
5337           if (TREE_VALUE (tail) == type)
5338             {
5339               if (name)
5340                 TREE_PURPOSE (tail) = name;
5341               return TREE_PURPOSE (tail);
5342             }
5343         }
5344     }
5345   return NULL_TREE;
5346 }
5347 \f
5348 /* Look up NAME in the NAMESPACE.  */
5349
5350 tree
5351 lookup_namespace_name (namespace, name)
5352      tree namespace, name;
5353 {
5354   tree val;
5355   tree template_id = NULL_TREE;
5356
5357   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5358
5359   if (TREE_CODE (name) == NAMESPACE_DECL)
5360     /* This happens for A::B<int> when B is a namespace. */
5361     return name;
5362   else if (TREE_CODE (name) == TEMPLATE_DECL)
5363     {
5364       /* This happens for A::B where B is a template, and there are no
5365          template arguments.  */
5366       cp_error ("invalid use of `%D'", name);
5367       return error_mark_node;
5368     }
5369
5370   namespace = ORIGINAL_NAMESPACE (namespace);
5371
5372   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5373     {
5374       template_id = name;
5375       name = TREE_OPERAND (name, 0);
5376       if (TREE_CODE (name) == OVERLOAD)
5377         name = DECL_NAME (OVL_CURRENT (name));
5378       else if (DECL_P (name))
5379         name = DECL_NAME (name);
5380     }
5381
5382   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5383
5384   val = make_node (CPLUS_BINDING);
5385   if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5386     return error_mark_node;
5387
5388   if (BINDING_VALUE (val))
5389     {
5390       val = BINDING_VALUE (val);
5391
5392       if (template_id)
5393         {
5394           if (DECL_CLASS_TEMPLATE_P (val))
5395             val = lookup_template_class (val,
5396                                          TREE_OPERAND (template_id, 1),
5397                                          /*in_decl=*/NULL_TREE,
5398                                          /*context=*/NULL_TREE,
5399                                          /*entering_scope=*/0);
5400           else if (DECL_FUNCTION_TEMPLATE_P (val)
5401                    || TREE_CODE (val) == OVERLOAD)
5402             val = lookup_template_function (val,
5403                                             TREE_OPERAND (template_id, 1));
5404           else
5405             {
5406               cp_error ("`%D::%D' is not a template",
5407                         namespace, name);
5408               return error_mark_node;
5409             }
5410         }
5411
5412       /* If we have a single function from a using decl, pull it out.  */
5413       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5414         val = OVL_FUNCTION (val);
5415       return val;
5416     }
5417
5418   cp_error ("`%D' undeclared in namespace `%D'", name, namespace);
5419   return error_mark_node;
5420 }
5421
5422 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
5423
5424 static unsigned long
5425 typename_hash (k)
5426      hash_table_key k;
5427 {
5428   unsigned long hash;
5429   tree t;
5430
5431   t = (tree) k;
5432   hash = (((unsigned long) TYPE_CONTEXT (t))
5433           ^ ((unsigned long) DECL_NAME (TYPE_NAME (t))));
5434
5435   return hash;
5436 }
5437
5438 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
5439
5440 static boolean
5441 typename_compare (k1, k2)
5442      hash_table_key k1;
5443      hash_table_key k2;
5444 {
5445   tree t1;
5446   tree t2;
5447   tree d1;
5448   tree d2;
5449
5450   t1 = (tree) k1;
5451   t2 = (tree) k2;
5452   d1 = TYPE_NAME (t1);
5453   d2 = TYPE_NAME (t2);
5454
5455   return (DECL_NAME (d1) == DECL_NAME (d2)
5456           && same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))
5457           && ((TREE_TYPE (t1) != NULL_TREE)
5458               == (TREE_TYPE (t2) != NULL_TREE))
5459           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5460           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5461 }
5462
5463 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
5464    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
5465    is non-NULL, this type is being created by the implicit typename
5466    extension, and BASE_TYPE is a type named `t' in some base class of
5467    `T' which depends on template parameters.
5468
5469    Returns the new TYPENAME_TYPE.  */
5470
5471 tree
5472 build_typename_type (context, name, fullname, base_type)
5473      tree context;
5474      tree name;
5475      tree fullname;
5476      tree base_type;
5477 {
5478   tree t;
5479   tree d;
5480   struct hash_entry* e;
5481
5482   static struct hash_table ht;
5483
5484   if (!ht.table)
5485     {
5486       static struct hash_table *h = &ht;
5487       if (!hash_table_init (&ht, &hash_newfunc, &typename_hash,
5488                             &typename_compare))
5489         fatal ("virtual memory exhausted");
5490       ggc_add_tree_hash_table_root (&h, 1);
5491     }
5492
5493   /* Build the TYPENAME_TYPE.  */
5494   t = make_aggr_type (TYPENAME_TYPE);
5495   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5496   TYPENAME_TYPE_FULLNAME (t) = fullname;
5497   TREE_TYPE (t) = base_type;
5498
5499   /* Build the corresponding TYPE_DECL.  */
5500   d = build_decl (TYPE_DECL, name, t);
5501   TYPE_NAME (TREE_TYPE (d)) = d;
5502   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5503   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5504   DECL_ARTIFICIAL (d) = 1;
5505
5506   /* See if we already have this type.  */
5507   e = hash_lookup (&ht, t, /*create=*/false, /*copy=*/0);
5508   if (e)
5509     t = (tree) e->key;
5510   else
5511     /* Insert the type into the table.  */
5512     hash_lookup (&ht, t, /*create=*/true, /*copy=*/0);
5513
5514   return t;
5515 }
5516
5517 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
5518    unless an error occurs, in which case error_mark_node is returned.
5519    If COMPLAIN zero, don't complain about any errors that occur.  */
5520
5521 tree
5522 make_typename_type (context, name, complain)
5523      tree context, name;
5524      int complain;
5525 {
5526   tree fullname;
5527
5528   if (TYPE_P (name))
5529     {
5530       if (!(TYPE_LANG_SPECIFIC (name)
5531             && (CLASSTYPE_IS_TEMPLATE (name)
5532                 || CLASSTYPE_USE_TEMPLATE (name))))
5533         name = TYPE_IDENTIFIER (name);
5534       else
5535         /* Create a TEMPLATE_ID_EXPR for the type.  */
5536         name = build_nt (TEMPLATE_ID_EXPR,
5537                          CLASSTYPE_TI_TEMPLATE (name),
5538                          CLASSTYPE_TI_ARGS (name));
5539     }
5540   else if (TREE_CODE (name) == TYPE_DECL)
5541     name = DECL_NAME (name);
5542
5543   fullname = name;
5544
5545   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5546     {
5547       name = TREE_OPERAND (name, 0);
5548       if (TREE_CODE (name) == TEMPLATE_DECL)
5549         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5550     }
5551   if (TREE_CODE (name) != IDENTIFIER_NODE)
5552     my_friendly_abort (2000);
5553
5554   if (TREE_CODE (context) == NAMESPACE_DECL)
5555     {
5556       /* We can get here from typename_sub0 in the explicit_template_type
5557          expansion.  Just fail.  */
5558       if (complain)
5559         cp_error ("no class template named `%#T' in `%#T'",
5560                   name, context);
5561       return error_mark_node;
5562     }
5563
5564   if (! uses_template_parms (context)
5565       || currently_open_class (context))
5566     {
5567       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5568         {
5569           tree tmpl = NULL_TREE;
5570           if (IS_AGGR_TYPE (context))
5571             tmpl = lookup_field (context, name, 0, 0);
5572           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5573             {
5574               if (complain)
5575                 cp_error ("no class template named `%#T' in `%#T'",
5576                           name, context);
5577               return error_mark_node;
5578             }
5579
5580           return lookup_template_class (tmpl,
5581                                         TREE_OPERAND (fullname, 1),
5582                                         NULL_TREE, context,
5583                                         /*entering_scope=*/0);
5584         }
5585       else
5586         {
5587           tree t;
5588
5589           if (!IS_AGGR_TYPE (context))
5590             {
5591               if (complain)
5592                 cp_error ("no type named `%#T' in `%#T'", name, context);
5593               return error_mark_node;
5594             }
5595
5596           t = lookup_field (context, name, 0, 1);
5597           if (t)
5598             return TREE_TYPE (t);
5599         }
5600     }
5601
5602   /* If the CONTEXT is not a template type, then either the field is
5603      there now or its never going to be.  */
5604   if (!uses_template_parms (context))
5605     {
5606       if (complain)
5607         cp_error ("no type named `%#T' in `%#T'", name, context);
5608       return error_mark_node;
5609     }
5610
5611
5612   return build_typename_type (context, name, fullname,  NULL_TREE);
5613 }
5614
5615 /* Select the right _DECL from multiple choices. */
5616
5617 static tree
5618 select_decl (binding, flags)
5619      tree binding;
5620      int flags;
5621 {
5622   tree val;
5623   val = BINDING_VALUE (binding);
5624   if (LOOKUP_NAMESPACES_ONLY (flags))
5625     {
5626       /* We are not interested in types. */
5627       if (val && TREE_CODE (val) == NAMESPACE_DECL)
5628         return val;
5629       return NULL_TREE;
5630     }
5631
5632   /* If we could have a type and
5633      we have nothing or we need a type and have none.  */
5634   if (BINDING_TYPE (binding)
5635       && (!val || ((flags & LOOKUP_PREFER_TYPES)
5636                    && TREE_CODE (val) != TYPE_DECL)))
5637     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5638   /* Don't return non-types if we really prefer types. */
5639   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
5640            && (TREE_CODE (val) != TEMPLATE_DECL
5641                || !DECL_CLASS_TEMPLATE_P (val)))
5642     val = NULL_TREE;
5643
5644   return val;
5645 }
5646
5647 /* Unscoped lookup of a global: iterate over current namespaces,
5648    considering using-directives.  If SPACESP is non-NULL, store a list
5649    of the namespaces we've considered in it.  */
5650
5651 tree
5652 unqualified_namespace_lookup (name, flags, spacesp)
5653      tree name;
5654      int flags;
5655      tree *spacesp;
5656 {
5657   tree b = make_node (CPLUS_BINDING);
5658   tree initial = current_decl_namespace();
5659   tree scope = initial;
5660   tree siter;
5661   struct binding_level *level;
5662   tree val = NULL_TREE;
5663
5664   if (spacesp)
5665     *spacesp = NULL_TREE;
5666
5667   for (; !val; scope = CP_DECL_CONTEXT (scope))
5668     {
5669       if (spacesp)
5670         *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5671       val = binding_for_name (name, scope);
5672
5673       /* Initialize binding for this context. */
5674       BINDING_VALUE (b) = BINDING_VALUE (val);
5675       BINDING_TYPE (b) = BINDING_TYPE (val);
5676
5677       /* Add all _DECLs seen through local using-directives. */
5678       for (level = current_binding_level;
5679            !level->namespace_p;
5680            level = level->level_chain)
5681         if (!lookup_using_namespace (name, b, level->using_directives,
5682                                      scope, flags, spacesp))
5683           /* Give up because of error. */
5684           return error_mark_node;
5685
5686       /* Add all _DECLs seen through global using-directives. */
5687       /* XXX local and global using lists should work equally. */
5688       siter = initial;
5689       while (1)
5690         {
5691           if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5692                                        scope, flags, spacesp))
5693             /* Give up because of error. */
5694             return error_mark_node;
5695           if (siter == scope) break;
5696           siter = CP_DECL_CONTEXT (siter);
5697         }
5698
5699       val = select_decl (b, flags);
5700       if (scope == global_namespace)
5701         break;
5702     }
5703   return val;
5704 }
5705
5706 /* Combine prefer_type and namespaces_only into flags.  */
5707
5708 static int
5709 lookup_flags (prefer_type, namespaces_only)
5710   int prefer_type, namespaces_only;
5711 {
5712   if (namespaces_only)
5713     return LOOKUP_PREFER_NAMESPACES;
5714   if (prefer_type > 1)
5715     return LOOKUP_PREFER_TYPES;
5716   if (prefer_type > 0)
5717     return LOOKUP_PREFER_BOTH;
5718   return 0;
5719 }
5720
5721 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5722    ignore it or not.  Subroutine of lookup_name_real.  */
5723
5724 static tree
5725 qualify_lookup (val, flags)
5726      tree val;
5727      int flags;
5728 {
5729   if (val == NULL_TREE)
5730     return val;
5731   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5732     return val;
5733   if ((flags & LOOKUP_PREFER_TYPES)
5734       && (TREE_CODE (val) == TYPE_DECL
5735           || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5736               && DECL_CLASS_TEMPLATE_P (val))))
5737     return val;
5738   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5739     return NULL_TREE;
5740   return val;
5741 }
5742
5743 /* Any other BINDING overrides an implicit TYPENAME.  Warn about
5744    that.  */
5745
5746 static void
5747 warn_about_implicit_typename_lookup (typename, binding)
5748      tree typename;
5749      tree binding;
5750 {
5751   tree subtype = TREE_TYPE (TREE_TYPE (typename));
5752   tree name = DECL_NAME (typename);
5753
5754   if (! (TREE_CODE (binding) == TEMPLATE_DECL
5755          && CLASSTYPE_TEMPLATE_INFO (subtype)
5756          && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
5757       && ! (TREE_CODE (binding) == TYPE_DECL
5758             && same_type_p (TREE_TYPE (binding), subtype)))
5759     {
5760       cp_warning ("lookup of `%D' finds `%#D'",
5761                   name, binding);
5762       cp_warning ("  instead of `%D' from dependent base class",
5763                   typename);
5764       cp_warning ("  (use `typename %T::%D' if that's what you meant)",
5765                   constructor_name (current_class_type), name);
5766     }
5767 }
5768
5769 /* Look up NAME in the current binding level and its superiors in the
5770    namespace of variables, functions and typedefs.  Return a ..._DECL
5771    node of some kind representing its definition if there is only one
5772    such declaration, or return a TREE_LIST with all the overloaded
5773    definitions if there are many, or return 0 if it is undefined.
5774
5775    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5776    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5777    If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5778    Otherwise we prefer non-TYPE_DECLs.
5779
5780    If NONCLASS is non-zero, we don't look for the NAME in class scope,
5781    using IDENTIFIER_CLASS_VALUE.  */
5782
5783 static tree
5784 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
5785      tree name;
5786      int prefer_type, nonclass, namespaces_only;
5787 {
5788   tree t;
5789   tree val = NULL_TREE;
5790   int yylex = 0;
5791   tree from_obj = NULL_TREE;
5792   int flags;
5793   int val_is_implicit_typename = 0;
5794
5795   /* Hack: copy flag set by parser, if set. */
5796   if (only_namespace_names)
5797     namespaces_only = 1;
5798
5799   if (prefer_type == -2)
5800     {
5801       extern int looking_for_typename;
5802       tree type = NULL_TREE;
5803
5804       yylex = 1;
5805       prefer_type = looking_for_typename;
5806
5807       flags = lookup_flags (prefer_type, namespaces_only);
5808       /* If the next thing is '<', class templates are types. */
5809       if (looking_for_template)
5810         flags |= LOOKUP_TEMPLATES_EXPECTED;
5811
5812       /* std:: becomes :: for now.  */
5813       if (got_scope == std_node)
5814         got_scope = void_type_node;
5815
5816       if (got_scope)
5817         type = got_scope;
5818       else if (got_object != error_mark_node)
5819         type = got_object;
5820
5821       if (type)
5822         {
5823           if (type == error_mark_node)
5824             return error_mark_node;
5825           if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
5826             type = TREE_TYPE (type);
5827
5828           if (TYPE_P (type))
5829             type = complete_type (type);
5830
5831           if (TREE_CODE (type) == VOID_TYPE)
5832             type = global_namespace;
5833           if (TREE_CODE (type) == NAMESPACE_DECL)
5834             {
5835               val = make_node (CPLUS_BINDING);
5836               flags |= LOOKUP_COMPLAIN;
5837               if (!qualified_lookup_using_namespace (name, type, val, flags))
5838                 return NULL_TREE;
5839               val = select_decl (val, flags);
5840             }
5841           else if (! IS_AGGR_TYPE (type)
5842                    || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5843                    || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM
5844                    || TREE_CODE (type) == TYPENAME_TYPE)
5845             /* Someone else will give an error about this if needed.  */
5846             val = NULL_TREE;
5847           else if (type == current_class_type)
5848             val = IDENTIFIER_CLASS_VALUE (name);
5849           else
5850             {
5851               val = lookup_member (type, name, 0, prefer_type);
5852               type_access_control (type, val);
5853             }
5854         }
5855       else
5856         val = NULL_TREE;
5857
5858       if (got_scope)
5859         goto done;
5860       else if (got_object && val)
5861         from_obj = val;
5862     }
5863   else
5864     {
5865       flags = lookup_flags (prefer_type, namespaces_only);
5866       /* If we're not parsing, we need to complain. */
5867       flags |= LOOKUP_COMPLAIN;
5868     }
5869
5870   /* First, look in non-namespace scopes.  */
5871
5872   if (current_class_type == NULL_TREE)
5873     nonclass = 1;
5874
5875   for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
5876     {
5877       tree binding;
5878
5879       if (!LOCAL_BINDING_P (t) && nonclass)
5880         /* We're not looking for class-scoped bindings, so keep going.  */
5881         continue;
5882
5883       /* If this is the kind of thing we're looking for, we're done.  */
5884       if (qualify_lookup (BINDING_VALUE (t), flags))
5885         binding = BINDING_VALUE (t);
5886       else if ((flags & LOOKUP_PREFER_TYPES)
5887                && qualify_lookup (BINDING_TYPE (t), flags))
5888         binding = BINDING_TYPE (t);
5889       else
5890         binding = NULL_TREE;
5891
5892       /* Handle access control on types from enclosing or base classes.  */
5893       if (binding && ! yylex
5894           && BINDING_LEVEL (t) && BINDING_LEVEL (t)->parm_flag == 2)
5895         type_access_control (BINDING_LEVEL (t)->this_class, binding);
5896
5897       if (binding
5898           && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
5899         {
5900           if (val_is_implicit_typename && !yylex)
5901             warn_about_implicit_typename_lookup (val, binding);
5902           val = binding;
5903           val_is_implicit_typename
5904             = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
5905           if (!val_is_implicit_typename)
5906             break;
5907         }
5908     }
5909
5910   /* Now lookup in namespace scopes.  */
5911   if (!val || val_is_implicit_typename)
5912     {
5913       t = unqualified_namespace_lookup (name, flags, 0);
5914       if (t)
5915         {
5916           if (val_is_implicit_typename && !yylex)
5917             warn_about_implicit_typename_lookup (val, t);
5918           val = t;
5919         }
5920     }
5921
5922  done:
5923   if (val)
5924     {
5925       /* This should only warn about types used in qualified-ids.  */
5926       if (from_obj && from_obj != val)
5927         {
5928           if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
5929               && TREE_CODE (val) == TYPE_DECL
5930               && TREE_TYPE (from_obj) != TREE_TYPE (val))
5931             {
5932               cp_pedwarn ("lookup of `%D' in the scope of `%#T' (`%#T')",
5933                           name, got_object, TREE_TYPE (from_obj));
5934               cp_pedwarn ("  does not match lookup in the current scope (`%#T')",
5935                           TREE_TYPE (val));
5936             }
5937
5938           /* We don't change val to from_obj if got_object depends on
5939              template parms because that breaks implicit typename for
5940              destructor calls.  */
5941           if (! uses_template_parms (got_object))
5942             val = from_obj;
5943         }
5944
5945       /* If we have a single function from a using decl, pull it out.  */
5946       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5947         val = OVL_FUNCTION (val);
5948     }
5949   else if (from_obj)
5950     val = from_obj;
5951
5952   return val;
5953 }
5954
5955 tree
5956 lookup_name_nonclass (name)
5957      tree name;
5958 {
5959   return lookup_name_real (name, 0, 1, 0);
5960 }
5961
5962 tree
5963 lookup_function_nonclass (name, args)
5964      tree name;
5965      tree args;
5966 {
5967   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
5968 }
5969
5970 tree
5971 lookup_name_namespace_only (name)
5972      tree name;
5973 {
5974   /* type-or-namespace, nonclass, namespace_only */
5975   return lookup_name_real (name, 1, 1, 1);
5976 }
5977
5978 tree
5979 lookup_name (name, prefer_type)
5980      tree name;
5981      int prefer_type;
5982 {
5983   return lookup_name_real (name, prefer_type, 0, 0);
5984 }
5985
5986 /* Similar to `lookup_name' but look only in the innermost non-class
5987    binding level.  */
5988
5989 tree
5990 lookup_name_current_level (name)
5991      tree name;
5992 {
5993   struct binding_level *b;
5994   tree t = NULL_TREE;
5995
5996   b = current_binding_level;
5997   while (b->parm_flag == 2)
5998     b = b->level_chain;
5999
6000   if (b->namespace_p)
6001     {
6002       t = IDENTIFIER_NAMESPACE_VALUE (name);
6003
6004       /* extern "C" function() */
6005       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
6006         t = TREE_VALUE (t);
6007     }
6008   else if (IDENTIFIER_BINDING (name)
6009            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
6010     {
6011       while (1)
6012         {
6013           if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
6014             return IDENTIFIER_VALUE (name);
6015
6016           if (b->keep == 2)
6017             b = b->level_chain;
6018           else
6019             break;
6020         }
6021     }
6022
6023   return t;
6024 }
6025
6026 /* Like lookup_name_current_level, but for types.  */
6027
6028 tree
6029 lookup_type_current_level (name)
6030      tree name;
6031 {
6032   register tree t = NULL_TREE;
6033
6034   my_friendly_assert (! current_binding_level->namespace_p, 980716);
6035
6036   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
6037       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
6038     {
6039       struct binding_level *b = current_binding_level;
6040       while (1)
6041         {
6042           if (purpose_member (name, b->type_shadowed))
6043             return REAL_IDENTIFIER_TYPE_VALUE (name);
6044           if (b->keep == 2)
6045             b = b->level_chain;
6046           else
6047             break;
6048         }
6049     }
6050
6051   return t;
6052 }
6053
6054 void
6055 begin_only_namespace_names ()
6056 {
6057   only_namespace_names = 1;
6058 }
6059
6060 void
6061 end_only_namespace_names ()
6062 {
6063   only_namespace_names = 0;
6064 }
6065 \f
6066 /* Arrange for the user to get a source line number, even when the
6067    compiler is going down in flames, so that she at least has a
6068    chance of working around problems in the compiler.  We used to
6069    call error(), but that let the segmentation fault continue
6070    through; now, it's much more passive by asking them to send the
6071    maintainers mail about the problem.  */
6072
6073 static void
6074 signal_catch (sig)
6075      int sig ATTRIBUTE_UNUSED;
6076 {
6077   signal (SIGSEGV, SIG_DFL);
6078 #ifdef SIGIOT
6079   signal (SIGIOT, SIG_DFL);
6080 #endif
6081 #ifdef SIGILL
6082   signal (SIGILL, SIG_DFL);
6083 #endif
6084 #ifdef SIGABRT
6085   signal (SIGABRT, SIG_DFL);
6086 #endif
6087 #ifdef SIGBUS
6088   signal (SIGBUS, SIG_DFL);
6089 #endif
6090   my_friendly_abort (0);
6091 }
6092
6093 /* Push the declarations of builtin types into the namespace.
6094    RID_INDEX, if < RID_MAX is the index of the builtin type
6095    in the array RID_POINTERS.  NAME is the name used when looking
6096    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
6097
6098 static void
6099 record_builtin_type (rid_index, name, type)
6100      enum rid rid_index;
6101      const char *name;
6102      tree type;
6103 {
6104   tree rname = NULL_TREE, tname = NULL_TREE;
6105   tree tdecl = NULL_TREE;
6106
6107   if ((int) rid_index < (int) RID_MAX)
6108     rname = ridpointers[(int) rid_index];
6109   if (name)
6110     tname = get_identifier (name);
6111
6112   TYPE_BUILT_IN (type) = 1;
6113
6114   if (tname)
6115     {
6116       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
6117       set_identifier_type_value (tname, NULL_TREE);
6118       if ((int) rid_index < (int) RID_MAX)
6119         /* Built-in types live in the global namespace. */
6120         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
6121     }
6122   if (rname != NULL_TREE)
6123     {
6124       if (tname != NULL_TREE)
6125         {
6126           set_identifier_type_value (rname, NULL_TREE);
6127           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
6128         }
6129       else
6130         {
6131           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
6132           set_identifier_type_value (rname, NULL_TREE);
6133         }
6134     }
6135 }
6136
6137 /* Record one of the standard Java types.
6138  * Declare it as having the given NAME.
6139  * If SIZE > 0, it is the size of one of the integral types;
6140  * otherwise it is the negative of the size of one of the other types.  */
6141
6142 static tree
6143 record_builtin_java_type (name, size)
6144      const char *name;
6145      int size;
6146 {
6147   tree type, decl;
6148   if (size > 0)
6149     type = make_signed_type (size);
6150   else if (size > -32)
6151     { /* "__java_char" or ""__java_boolean". */
6152       type = make_unsigned_type (-size);
6153       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6154     }
6155   else
6156     { /* "__java_float" or ""__java_double". */
6157       type = make_node (REAL_TYPE);
6158       TYPE_PRECISION (type) = - size;
6159       layout_type (type);
6160     }
6161   record_builtin_type (RID_MAX, name, type);
6162   decl = TYPE_NAME (type);
6163
6164   /* Suppress generate debug symbol entries for these types,
6165      since for normal C++ they are just clutter.
6166      However, push_lang_context undoes this if extern "Java" is seen. */
6167   DECL_IGNORED_P (decl) = 1;
6168
6169   TYPE_FOR_JAVA (type) = 1;
6170   return type;
6171 }
6172
6173 /* Push a type into the namespace so that the back-ends ignore it. */
6174
6175 static void
6176 record_unknown_type (type, name)
6177      tree type;
6178      const char *name;
6179 {
6180   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
6181   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
6182   DECL_IGNORED_P (decl) = 1;
6183   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6184   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
6185   TYPE_ALIGN (type) = 1;
6186   TYPE_MODE (type) = TYPE_MODE (void_type_node);
6187 }
6188
6189 /* An string for which we should create an IDENTIFIER_NODE at
6190    startup.  */
6191
6192 typedef struct predefined_identifier
6193 {
6194   /* The name of the identifier.  */
6195   const char *name;
6196   /* The place where the IDENTIFIER_NODE should be stored.  */
6197   tree *node;
6198   /* Non-zero if this is the name of a constructor or destructor.  */
6199   int ctor_or_dtor_p;
6200 } predefined_identifier;
6201
6202 /* Create all the predefined identifiers.  */
6203
6204 static void
6205 initialize_predefined_identifiers ()
6206 {
6207   struct predefined_identifier *pid;
6208
6209   /* A table of identifiers to create at startup.  */
6210   static predefined_identifier predefined_identifiers[] = {
6211     { "C++", &lang_name_cplusplus, 0 },
6212     { "C", &lang_name_c, 0 },
6213     { "Java", &lang_name_java, 0 },
6214     { CTOR_NAME, &ctor_identifier, 1 },
6215     { "__base_ctor", &base_ctor_identifier, 1 },
6216     { "__comp_ctor", &complete_ctor_identifier, 1 },
6217     { DTOR_NAME, &dtor_identifier, 1 },
6218     { "__comp_dtor", &complete_dtor_identifier, 1 },
6219     { "__base_dtor", &base_dtor_identifier, 1 },
6220     { "__deleting_dtor", &deleting_dtor_identifier, 1 },
6221     { VTABLE_DELTA2_NAME, &delta2_identifier, 0 },
6222     { VTABLE_DELTA_NAME, &delta_identifier, 0 },
6223     { IN_CHARGE_NAME, &in_charge_identifier, 0 },
6224     { VTABLE_INDEX_NAME, &index_identifier, 0 },
6225     { "nelts", &nelts_identifier, 0 },
6226     { THIS_NAME, &this_identifier, 0 },
6227     { VTABLE_PFN_NAME, &pfn_identifier, 0 },
6228     { "__pfn_or_delta2", &pfn_or_delta2_identifier, 0 },
6229     { "_vptr", &vptr_identifier, 0 },
6230     { "__cp_push_exception", &cp_push_exception_identifier, 0 },
6231     { "__vtt_parm", &vtt_parm_identifier, 0 },
6232     { NULL, NULL, 0 }
6233   };
6234
6235   for (pid = predefined_identifiers; pid->name; ++pid)
6236     {
6237       *pid->node = get_identifier (pid->name);
6238       if (pid->ctor_or_dtor_p)
6239         IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
6240     }
6241 }
6242
6243 /* Create the predefined scalar types of C,
6244    and some nodes representing standard constants (0, 1, (void *)0).
6245    Initialize the global binding level.
6246    Make definitions for built-in primitive functions.  */
6247
6248 void
6249 init_decl_processing ()
6250 {
6251   tree fields[20];
6252   int wchar_type_size;
6253   tree array_domain_type;
6254
6255   /* Check to see that the user did not specify an invalid combination
6256      of command-line options.  */
6257   if (flag_new_abi && !flag_vtable_thunks)
6258     fatal ("the new ABI requires vtable thunks");
6259
6260   /* Create all the identifiers we need.  */
6261   initialize_predefined_identifiers ();
6262
6263   /* Let the back-end now how to save and restore language-specific
6264      per-function globals.  */
6265   init_lang_status = &push_cp_function_context;
6266   free_lang_status = &pop_cp_function_context;
6267   mark_lang_status = &mark_cp_function_context;
6268
6269   cp_parse_init ();
6270   init_decl2 ();
6271   init_pt ();
6272
6273   /* Create the global variables.  */
6274   push_to_top_level ();
6275
6276   /* Enter the global namespace. */
6277   my_friendly_assert (global_namespace == NULL_TREE, 375);
6278   push_namespace (get_identifier ("::"));
6279   global_namespace = current_namespace;
6280   current_lang_name = NULL_TREE;
6281
6282   /* Adjust various flags based on command-line settings.  */
6283   if (flag_strict_prototype == 2)
6284     flag_strict_prototype = pedantic;
6285   if (! flag_permissive && ! pedantic)
6286     flag_pedantic_errors = 1;
6287   if (!flag_no_inline)
6288     flag_inline_trees = 1;
6289
6290   strict_prototypes_lang_c = flag_strict_prototype;
6291
6292   /* Initially, C.  */
6293   current_lang_name = lang_name_c;
6294
6295   current_function_decl = NULL_TREE;
6296   current_binding_level = NULL_BINDING_LEVEL;
6297   free_binding_level = NULL_BINDING_LEVEL;
6298
6299   /* Because most segmentation signals can be traced back into user
6300      code, catch them and at least give the user a chance of working
6301      around compiler bugs.  */
6302   signal (SIGSEGV, signal_catch);
6303
6304   /* We will also catch aborts in the back-end through signal_catch and
6305      give the user a chance to see where the error might be, and to defeat
6306      aborts in the back-end when there have been errors previously in their
6307      code.  */
6308 #ifdef SIGIOT
6309   signal (SIGIOT, signal_catch);
6310 #endif
6311 #ifdef SIGILL
6312   signal (SIGILL, signal_catch);
6313 #endif
6314 #ifdef SIGABRT
6315   signal (SIGABRT, signal_catch);
6316 #endif
6317 #ifdef SIGBUS
6318   signal (SIGBUS, signal_catch);
6319 #endif
6320
6321   build_common_tree_nodes (flag_signed_char);
6322
6323   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6324   TREE_TYPE (error_mark_list) = error_mark_node;
6325
6326   /* Make the binding_level structure for global names.  */
6327   pushlevel (0);
6328   global_binding_level = current_binding_level;
6329   /* The global level is the namespace level of ::.  */
6330   NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6331   declare_namespace_level ();
6332
6333   /* Define `int' and `char' first so that dbx will output them first.  */
6334   record_builtin_type (RID_INT, NULL_PTR, integer_type_node);
6335   record_builtin_type (RID_CHAR, "char", char_type_node);
6336
6337   /* `signed' is the same as `int' */
6338   record_builtin_type (RID_SIGNED, NULL_PTR, integer_type_node);
6339   record_builtin_type (RID_LONG, "long int", long_integer_type_node);
6340   record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
6341   record_builtin_type (RID_MAX, "long unsigned int", long_unsigned_type_node);
6342   record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
6343   record_builtin_type (RID_MAX, "long long int", long_long_integer_type_node);
6344   record_builtin_type (RID_MAX, "long long unsigned int",
6345                        long_long_unsigned_type_node);
6346   record_builtin_type (RID_MAX, "long long unsigned",
6347                        long_long_unsigned_type_node);
6348   record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
6349   record_builtin_type (RID_MAX, "short unsigned int", short_unsigned_type_node);
6350   record_builtin_type (RID_MAX, "unsigned short", short_unsigned_type_node);
6351
6352   ptrdiff_type_node
6353     = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE)));
6354
6355   /* Define both `signed char' and `unsigned char'.  */
6356   record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
6357   record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
6358
6359   /* `unsigned long' is the standard type for sizeof.
6360      Note that stddef.h uses `unsigned long',
6361      and this must agree, even if long and int are the same size.  */
6362   set_sizetype
6363     (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE))));
6364
6365   /* Create the widest literal types. */
6366   widest_integer_literal_type_node = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
6367   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6368                         widest_integer_literal_type_node));
6369
6370   widest_unsigned_literal_type_node = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
6371   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6372                         widest_unsigned_literal_type_node));
6373
6374   /* These are types that type_for_size and type_for_mode use.  */
6375   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
6376   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
6377   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
6378   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
6379 #if HOST_BITS_PER_WIDE_INT >= 64
6380   pushdecl (build_decl (TYPE_DECL, get_identifier ("__int128_t"), intTI_type_node));
6381 #endif
6382   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
6383   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
6384   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
6385   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
6386 #if HOST_BITS_PER_WIDE_INT >= 64
6387   pushdecl (build_decl (TYPE_DECL, get_identifier ("__uint128_t"), unsigned_intTI_type_node));
6388 #endif
6389
6390   build_common_tree_nodes_2 (flag_short_double);
6391
6392   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6393   java_short_type_node = record_builtin_java_type ("__java_short", 16);
6394   java_int_type_node = record_builtin_java_type ("__java_int", 32);
6395   java_long_type_node = record_builtin_java_type ("__java_long", 64);
6396   java_float_type_node = record_builtin_java_type ("__java_float", -32);
6397   java_double_type_node = record_builtin_java_type ("__java_double", -64);
6398   java_char_type_node = record_builtin_java_type ("__java_char", -16);
6399   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6400
6401   integer_two_node = build_int_2 (2, 0);
6402   TREE_TYPE (integer_two_node) = integer_type_node;
6403   integer_three_node = build_int_2 (3, 0);
6404   TREE_TYPE (integer_three_node) = integer_type_node;
6405
6406   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6407   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6408   TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6409   TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6410   TYPE_PRECISION (boolean_type_node) = 1;
6411   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6412   boolean_false_node = build_int_2 (0, 0);
6413   TREE_TYPE (boolean_false_node) = boolean_type_node;
6414   boolean_true_node = build_int_2 (1, 0);
6415   TREE_TYPE (boolean_true_node) = boolean_type_node;
6416
6417   signed_size_zero_node = build_int_2 (0, 0);
6418   record_builtin_type (RID_FLOAT, NULL_PTR, float_type_node);
6419   record_builtin_type (RID_DOUBLE, NULL_PTR, double_type_node);
6420   record_builtin_type (RID_MAX, "long double", long_double_type_node);
6421
6422   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
6423                         complex_integer_type_node));
6424   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
6425                         complex_float_type_node));
6426   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),
6427                         complex_double_type_node));
6428   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
6429                         complex_long_double_type_node));
6430
6431   TREE_TYPE (signed_size_zero_node) = make_signed_type (TYPE_PRECISION (sizetype));
6432
6433   record_builtin_type (RID_VOID, NULL_PTR, void_type_node);
6434   void_list_node = build_tree_list (NULL_TREE, void_type_node);
6435   TREE_PARMLIST (void_list_node) = 1;
6436
6437   /* Used for expressions that do nothing, but are not errors.  */
6438   void_zero_node = build_int_2 (0, 0);
6439   TREE_TYPE (void_zero_node) = void_type_node;
6440
6441   string_type_node = build_pointer_type (char_type_node);
6442   const_string_type_node
6443     = build_pointer_type (build_qualified_type (char_type_node,
6444                                                 TYPE_QUAL_CONST));
6445   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6446 #if 0
6447   record_builtin_type (RID_MAX, NULL_PTR, string_type_node);
6448 #endif
6449
6450   /* Make a type to be the domain of a few array types
6451      whose domains don't really matter.
6452      200 is small enough that it always fits in size_t.  */
6453   array_domain_type = build_index_type (build_int_2 (200, 0));
6454
6455   /* Make a type for arrays of characters.
6456      With luck nothing will ever really depend on the length of this
6457      array type.  */
6458   char_array_type_node
6459     = build_array_type (char_type_node, array_domain_type);
6460
6461   /* Likewise for arrays of ints.  */
6462   int_array_type_node
6463     = build_array_type (integer_type_node, array_domain_type);
6464
6465   record_component_aliases (char_array_type_node);
6466   record_component_aliases (int_array_type_node);
6467
6468   if (flag_new_abi)
6469     delta_type_node = ptrdiff_type_node;
6470   else if (flag_huge_objects)
6471     delta_type_node = long_integer_type_node;
6472   else
6473     delta_type_node = short_integer_type_node;
6474
6475   if (flag_new_abi)
6476     vtable_index_type = ptrdiff_type_node;
6477   else
6478     vtable_index_type = delta_type_node;
6479
6480   default_function_type
6481     = build_function_type (integer_type_node, NULL_TREE);
6482
6483   ptr_type_node = build_pointer_type (void_type_node);
6484   const_ptr_type_node
6485     = build_pointer_type (build_qualified_type (void_type_node,
6486                                                 TYPE_QUAL_CONST));
6487   vtt_parm_type = build_pointer_type (const_ptr_type_node);
6488   c_common_nodes_and_builtins (1, flag_no_builtin, flag_no_nonansi_builtin);
6489   lang_type_promotes_to = convert_type_from_ellipsis;
6490
6491   void_ftype_ptr
6492     = build_exception_variant (void_ftype_ptr, empty_except_spec);
6493
6494   /* C++ extensions */
6495
6496   unknown_type_node = make_node (UNKNOWN_TYPE);
6497   record_unknown_type (unknown_type_node, "unknown type");
6498
6499   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
6500   TREE_TYPE (unknown_type_node) = unknown_type_node;
6501
6502   TREE_TYPE (null_node) = type_for_size (POINTER_SIZE, 0);
6503
6504   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6505      result.  */
6506   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6507   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6508
6509   /* This is special for C++ so functions can be overloaded.  */
6510   wchar_type_node = get_identifier (flag_short_wchar
6511                                     ? "short unsigned int"
6512                                     : WCHAR_TYPE);
6513   wchar_type_node = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (wchar_type_node));
6514   wchar_type_size = TYPE_PRECISION (wchar_type_node);
6515   signed_wchar_type_node = make_signed_type (wchar_type_size);
6516   unsigned_wchar_type_node = make_unsigned_type (wchar_type_size);
6517   wchar_type_node
6518     = TREE_UNSIGNED (wchar_type_node)
6519       ? unsigned_wchar_type_node
6520       : signed_wchar_type_node;
6521   record_builtin_type (RID_WCHAR, "__wchar_t", wchar_type_node);
6522
6523   /* Artificial declaration of wchar_t -- can be bashed */
6524   wchar_decl_node = build_decl (TYPE_DECL, get_identifier ("wchar_t"),
6525                                 wchar_type_node);
6526   pushdecl (wchar_decl_node);
6527
6528   /* This is for wide string constants.  */
6529   wchar_array_type_node
6530     = build_array_type (wchar_type_node, array_domain_type);
6531   record_component_aliases (wchar_array_type_node);
6532
6533   if (flag_vtable_thunks)
6534     {
6535       /* Make sure we get a unique function type, so we can give
6536          its pointer type a name.  (This wins for gdb.) */
6537       tree vfunc_type = make_node (FUNCTION_TYPE);
6538       TREE_TYPE (vfunc_type) = integer_type_node;
6539       TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6540       layout_type (vfunc_type);
6541
6542       vtable_entry_type = build_pointer_type (vfunc_type);
6543     }
6544   else
6545     {
6546       vtable_entry_type = make_aggr_type (RECORD_TYPE);
6547       fields[0] = build_decl (FIELD_DECL, delta_identifier,
6548                               delta_type_node);
6549       fields[1] = build_decl (FIELD_DECL, index_identifier,
6550                               delta_type_node);
6551       fields[2] = build_decl (FIELD_DECL, pfn_identifier,
6552                               ptr_type_node);
6553       finish_builtin_type (vtable_entry_type, VTBL_PTR_TYPE, fields, 2,
6554                            double_type_node);
6555
6556       /* Make this part of an invisible union.  */
6557       fields[3] = copy_node (fields[2]);
6558       TREE_TYPE (fields[3]) = delta_type_node;
6559       DECL_NAME (fields[3]) = delta2_identifier;
6560       DECL_MODE (fields[3]) = TYPE_MODE (delta_type_node);
6561       DECL_SIZE (fields[3]) = TYPE_SIZE (delta_type_node);
6562       DECL_SIZE_UNIT (fields[3]) = TYPE_SIZE_UNIT (delta_type_node);
6563       TREE_UNSIGNED (fields[3]) = 0;
6564       TREE_CHAIN (fields[2]) = fields[3];
6565       vtable_entry_type = build_qualified_type (vtable_entry_type,
6566                                                 TYPE_QUAL_CONST);
6567     }
6568   record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6569
6570   vtbl_type_node
6571     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6572   layout_type (vtbl_type_node);
6573   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6574   record_builtin_type (RID_MAX, NULL_PTR, vtbl_type_node);
6575   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6576   layout_type (vtbl_ptr_type_node);
6577   record_builtin_type (RID_MAX, NULL_PTR, vtbl_ptr_type_node);
6578
6579   std_node = build_decl (NAMESPACE_DECL,
6580                          get_identifier (flag_honor_std ? "fake std":"std"),
6581                          void_type_node);
6582   pushdecl (std_node);
6583
6584   if (flag_new_abi)
6585     {
6586       push_namespace (get_identifier ("__cxxabiv1"));
6587       abi_node = current_namespace;
6588       pop_namespace ();
6589     }
6590
6591   global_type_node = make_node (LANG_TYPE);
6592   record_unknown_type (global_type_node, "global type");
6593
6594   /* Now, C++.  */
6595   current_lang_name = lang_name_cplusplus;
6596
6597   {
6598     tree bad_alloc_type_node, newtype, deltype;
6599     if (flag_honor_std)
6600       push_namespace (get_identifier ("std"));
6601     bad_alloc_type_node = xref_tag
6602       (class_type_node, get_identifier ("bad_alloc"), 1);
6603     if (flag_honor_std)
6604       pop_namespace ();
6605     newtype = build_exception_variant
6606       (ptr_ftype_sizetype, add_exception_specifier (NULL_TREE, bad_alloc_type_node, -1));
6607     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6608     push_cp_library_fn (NEW_EXPR, newtype);
6609     push_cp_library_fn (VEC_NEW_EXPR, newtype);
6610     global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
6611     push_cp_library_fn (VEC_DELETE_EXPR, deltype);
6612   }
6613
6614   abort_fndecl
6615     = build_library_fn_ptr ("__pure_virtual", void_ftype);
6616
6617   /* Perform other language dependent initializations.  */
6618   init_class_processing ();
6619   init_init_processing ();
6620   init_search_processing ();
6621   init_rtti_processing ();
6622
6623   if (flag_exceptions)
6624     init_exception_processing ();
6625   if (flag_no_inline)
6626     {
6627       flag_inline_functions = 0;
6628     }
6629
6630   if (! supports_one_only ())
6631     flag_weak = 0;
6632
6633   /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__.  */
6634   make_fname_decl = cp_make_fname_decl;
6635   declare_function_name ();
6636
6637   /* Prepare to check format strings against argument lists.  */
6638   init_function_format_info ();
6639
6640   /* Show we use EH for cleanups.  */
6641   using_eh_for_cleanups ();
6642
6643   print_error_function = lang_print_error_function;
6644   valid_lang_attribute = cp_valid_lang_attribute;
6645
6646   /* Maintain consistency.  Perhaps we should just complain if they
6647      say -fwritable-strings?  */
6648   if (flag_writable_strings)
6649     flag_const_strings = 0;
6650
6651   /* Add GC roots for all of our global variables.  */
6652   ggc_add_tree_root (c_global_trees, sizeof c_global_trees / sizeof(tree));
6653   ggc_add_tree_root (cp_global_trees, sizeof cp_global_trees / sizeof(tree));
6654   ggc_add_tree_root (&integer_three_node, 1);
6655   ggc_add_tree_root (&integer_two_node, 1);
6656   ggc_add_tree_root (&signed_size_zero_node, 1);
6657   ggc_add_tree_root (&size_one_node, 1);
6658   ggc_add_tree_root (&size_zero_node, 1);
6659   ggc_add_root (&global_binding_level, 1, sizeof global_binding_level,
6660                 mark_binding_level);
6661   ggc_add_root (&scope_chain, 1, sizeof scope_chain, &mark_saved_scope);
6662   ggc_add_tree_root (&static_ctors, 1);
6663   ggc_add_tree_root (&static_dtors, 1);
6664   ggc_add_tree_root (&lastiddecl, 1);
6665
6666   ggc_add_tree_root (&last_function_parm_tags, 1);
6667   ggc_add_tree_root (&current_function_return_value, 1);
6668   ggc_add_tree_root (&current_function_parms, 1);
6669   ggc_add_tree_root (&current_function_parm_tags, 1);
6670   ggc_add_tree_root (&last_function_parms, 1);
6671   ggc_add_tree_root (&error_mark_list, 1);
6672
6673   ggc_add_tree_root (&global_namespace, 1);
6674   ggc_add_tree_root (&global_type_node, 1);
6675   ggc_add_tree_root (&anonymous_namespace_name, 1);
6676
6677   ggc_add_tree_root (&got_object, 1);
6678   ggc_add_tree_root (&got_scope, 1);
6679
6680   ggc_add_tree_root (&current_lang_name, 1);
6681   ggc_add_tree_root (&static_aggregates, 1);
6682 }
6683
6684 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6685    decl, NAME is the initialization string and TYPE_DEP indicates whether
6686    NAME depended on the type of the function. We make use of that to detect
6687    __PRETTY_FUNCTION__ inside a template fn.  Because we build a tree for
6688    the function before emitting any of it, we don't need to treat the
6689    VAR_DECL specially. We can decide whether to emit it later, if it was
6690    used.  */
6691
6692 static tree
6693 cp_make_fname_decl (id, name, type_dep)
6694      tree id;
6695      const char *name;
6696      int type_dep;
6697 {
6698   tree decl, type, init;
6699   size_t length = strlen (name);
6700   tree domain = NULL_TREE;
6701
6702   if (!processing_template_decl)
6703     type_dep = 0;
6704   if (!type_dep)
6705     domain = build_index_type (build_int_2 (length, 0));
6706
6707   type =  build_cplus_array_type
6708           (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
6709            domain);
6710
6711   decl = build_decl (VAR_DECL, id, type);
6712   TREE_STATIC (decl) = 1;
6713   TREE_READONLY (decl) = 1;
6714   DECL_SOURCE_LINE (decl) = 0;
6715   DECL_ARTIFICIAL (decl) = 1;
6716   DECL_IN_SYSTEM_HEADER (decl) = 1;
6717   pushdecl (decl);
6718   if (processing_template_decl)
6719     decl = push_template_decl (decl);
6720   if (type_dep)
6721     {
6722       init = build (FUNCTION_NAME, type);
6723       DECL_PRETTY_FUNCTION_P (decl) = 1;
6724     }
6725   else
6726     {
6727       init = build_string (length + 1, name);
6728       TREE_TYPE (init) = type;
6729     }
6730   DECL_INITIAL (decl) = init;
6731   cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
6732
6733   /* We will have to make sure we only emit this, if it is actually used. */
6734   return decl;
6735 }
6736
6737 /* Function to print any language-specific context for an error message.  */
6738
6739 static void
6740 lang_print_error_function (file)
6741      const char *file;
6742 {
6743   default_print_error_function (file);
6744   maybe_print_template_context ();
6745 }
6746
6747 /* Entry point for the benefit of c_common_nodes_and_builtins.
6748
6749    Make a definition for a builtin function named NAME and whose data type
6750    is TYPE.  TYPE should be a function type with argument types.
6751
6752    CLASS and CODE tell later passes how to compile calls to this function.
6753    See tree.h for possible values.
6754
6755    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6756    the name to be called if we can't opencode the function.  */
6757
6758 tree
6759 builtin_function (name, type, code, class, libname)
6760      const char *name;
6761      tree type;
6762      int code;
6763      enum built_in_class class;
6764      const char *libname;
6765 {
6766   tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
6767   DECL_BUILT_IN_CLASS (decl) = class;
6768   DECL_FUNCTION_CODE (decl) = code;
6769
6770   my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 392);
6771
6772   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6773      we cannot change DECL_ASSEMBLER_NAME until we have installed this
6774      function in the namespace.  */
6775   pushdecl (decl);
6776   if (libname)
6777     DECL_ASSEMBLER_NAME (decl) = get_identifier (libname);
6778   make_function_rtl (decl);
6779
6780   /* Warn if a function in the namespace for users
6781      is used without an occasion to consider it declared.  */
6782   if (name[0] != '_' || name[1] != '_')
6783     DECL_ANTICIPATED (decl) = 1;
6784
6785   return decl;
6786 }
6787
6788 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
6789    function.  Not called directly.  */
6790
6791 static tree
6792 build_library_fn_1 (name, operator_code, type)
6793      tree name;
6794      enum tree_code operator_code;
6795      tree type;
6796 {
6797   tree fn = build_lang_decl (FUNCTION_DECL, name, type);
6798   DECL_EXTERNAL (fn) = 1;
6799   TREE_PUBLIC (fn) = 1;
6800   DECL_ARTIFICIAL (fn) = 1;
6801   TREE_NOTHROW (fn) = 1;
6802   SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
6803   return fn;
6804 }
6805
6806 /* Returns the _DECL for a library function with C linkage.
6807    We assume that such functions never throw; if this is incorrect,
6808    callers should unset TREE_NOTHROW.  */
6809
6810 tree
6811 build_library_fn (name, type)
6812      tree name;
6813      tree type;
6814 {
6815   tree fn = build_library_fn_1 (name, ERROR_MARK, type);
6816   make_function_rtl (fn);
6817   return fn;
6818 }
6819
6820 /* Returns the _DECL for a library function with C++ linkage.  */
6821
6822 static tree
6823 build_cp_library_fn (name, operator_code, type)
6824      tree name;
6825      enum tree_code operator_code;
6826      tree type;
6827 {
6828   tree fn = build_library_fn_1 (name, operator_code, type);
6829   TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
6830   DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
6831   set_mangled_name_for_decl (fn);
6832   make_function_rtl (fn);
6833   return fn;
6834 }
6835
6836 /* Like build_library_fn, but takes a C string instead of an
6837    IDENTIFIER_NODE.  */
6838
6839 tree
6840 build_library_fn_ptr (name, type)
6841      const char *name;
6842      tree type;
6843 {
6844   return build_library_fn (get_identifier (name), type);
6845 }
6846
6847 /* Like build_cp_library_fn, but takes a C string instead of an
6848    IDENTIFIER_NODE.  */
6849
6850 tree
6851 build_cp_library_fn_ptr (name, type)
6852      const char *name;
6853      tree type;
6854 {
6855   return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
6856 }
6857
6858 /* Like build_library_fn, but also pushes the function so that we will
6859    be able to find it via IDENTIFIER_GLOBAL_VALUE.  */
6860
6861 tree
6862 push_library_fn (name, type)
6863      tree name, type;
6864 {
6865   tree fn = build_library_fn (name, type);
6866   pushdecl_top_level (fn);
6867   return fn;
6868 }
6869
6870 /* Like build_cp_library_fn, but also pushes the function so that it
6871    will be found by normal lookup.  */
6872
6873 static tree
6874 push_cp_library_fn (operator_code, type)
6875      enum tree_code operator_code;
6876      tree type;
6877 {
6878   tree fn = build_cp_library_fn (ansi_opname (operator_code),
6879                                  operator_code,
6880                                  type);
6881   pushdecl (fn);
6882   return fn;
6883 }
6884
6885 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
6886    a FUNCTION_TYPE.  */
6887
6888 tree
6889 push_void_library_fn (name, parmtypes)
6890      tree name, parmtypes;
6891 {
6892   tree type = build_function_type (void_type_node, parmtypes);
6893   return push_library_fn (name, type);
6894 }
6895
6896 /* Like push_library_fn, but also note that this function throws
6897    and does not return.  Used for __throw_foo and the like.  */
6898
6899 tree
6900 push_throw_library_fn (name, type)
6901      tree name, type;
6902 {
6903   tree fn = push_library_fn (name, type);
6904   TREE_THIS_VOLATILE (fn) = 1;
6905   TREE_NOTHROW (fn) = 0;
6906   return fn;
6907 }
6908 \f
6909 /* When we call finish_struct for an anonymous union, we create
6910    default copy constructors and such.  But, an anonymous union
6911    shouldn't have such things; this function undoes the damage to the
6912    anonymous union type T.
6913
6914    (The reason that we create the synthesized methods is that we don't
6915    distinguish `union { int i; }' from `typedef union { int i; } U'.
6916    The first is an anonymous union; the second is just an ordinary
6917    union type.)  */
6918
6919 void
6920 fixup_anonymous_aggr (t)
6921      tree t;
6922 {
6923   tree *q;
6924
6925   /* Wipe out memory of synthesized methods */
6926   TYPE_HAS_CONSTRUCTOR (t) = 0;
6927   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6928   TYPE_HAS_INIT_REF (t) = 0;
6929   TYPE_HAS_CONST_INIT_REF (t) = 0;
6930   TYPE_HAS_ASSIGN_REF (t) = 0;
6931   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6932
6933   /* Splice the implicitly generated functions out of the TYPE_METHODS
6934      list.  */
6935   q = &TYPE_METHODS (t);
6936   while (*q)
6937     {
6938       if (DECL_ARTIFICIAL (*q))
6939         *q = TREE_CHAIN (*q);
6940       else
6941         q = &TREE_CHAIN (*q);
6942     }
6943
6944   /* ISO C++ 9.5.3.  Anonymous unions may not have function members.  */
6945   if (TYPE_METHODS (t))
6946     error ("an anonymous union cannot have function members");
6947 }
6948
6949 /* Make sure that a declaration with no declarator is well-formed, i.e.
6950    just defines a tagged type or anonymous union.
6951
6952    Returns the type defined, if any.  */
6953
6954 tree
6955 check_tag_decl (declspecs)
6956      tree declspecs;
6957 {
6958   int found_type = 0;
6959   int saw_friend = 0;
6960   tree ob_modifier = NULL_TREE;
6961   register tree link;
6962   register tree t = NULL_TREE;
6963
6964   for (link = declspecs; link; link = TREE_CHAIN (link))
6965     {
6966       register tree value = TREE_VALUE (link);
6967
6968       if (TYPE_P (value)
6969           || (TREE_CODE (value) == IDENTIFIER_NODE
6970               && IDENTIFIER_GLOBAL_VALUE (value)
6971               && TYPE_P (IDENTIFIER_GLOBAL_VALUE (value))))
6972         {
6973           ++found_type;
6974
6975           if (IS_AGGR_TYPE (value) || TREE_CODE (value) == ENUMERAL_TYPE)
6976             {
6977               my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
6978               t = value;
6979             }
6980         }
6981       else if (value == ridpointers[(int) RID_FRIEND])
6982         {
6983           if (current_class_type == NULL_TREE
6984               || current_scope () != current_class_type)
6985             ob_modifier = value;
6986           else
6987             saw_friend = 1;
6988         }
6989       else if (value == ridpointers[(int) RID_STATIC]
6990                || value == ridpointers[(int) RID_EXTERN]
6991                || value == ridpointers[(int) RID_AUTO]
6992                || value == ridpointers[(int) RID_REGISTER]
6993                || value == ridpointers[(int) RID_INLINE]
6994                || value == ridpointers[(int) RID_VIRTUAL]
6995                || value == ridpointers[(int) RID_CONST]
6996                || value == ridpointers[(int) RID_VOLATILE]
6997                || value == ridpointers[(int) RID_EXPLICIT])
6998         ob_modifier = value;
6999     }
7000
7001   if (found_type > 1)
7002     error ("multiple types in one declaration");
7003
7004   if (t == NULL_TREE && ! saw_friend)
7005     pedwarn ("declaration does not declare anything");
7006
7007   /* Check for an anonymous union.  We're careful
7008      accessing TYPE_IDENTIFIER because some built-in types, like
7009      pointer-to-member types, do not have TYPE_NAME.  */
7010   else if (t && IS_AGGR_TYPE_CODE (TREE_CODE (t))
7011            && TYPE_NAME (t)
7012            && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
7013     {
7014       /* Anonymous unions are objects, so they can have specifiers.  */;
7015       SET_ANON_AGGR_TYPE_P (t);
7016
7017       if (TREE_CODE (t) != UNION_TYPE && pedantic && ! in_system_header)
7018         pedwarn ("ISO C++ prohibits anonymous structs");
7019     }
7020
7021   else if (ob_modifier)
7022     {
7023       if (ob_modifier == ridpointers[(int) RID_INLINE]
7024           || ob_modifier == ridpointers[(int) RID_VIRTUAL])
7025         cp_error ("`%D' can only be specified for functions", ob_modifier);
7026       else if (ob_modifier == ridpointers[(int) RID_FRIEND])
7027         cp_error ("`%D' can only be specified inside a class", ob_modifier);
7028       else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
7029         cp_error ("`%D' can only be specified for constructors",
7030                   ob_modifier);
7031       else
7032         cp_error ("`%D' can only be specified for objects and functions",
7033                   ob_modifier);
7034     }
7035
7036   return t;
7037 }
7038
7039 /* Called when a declaration is seen that contains no names to declare.
7040    If its type is a reference to a structure, union or enum inherited
7041    from a containing scope, shadow that tag name for the current scope
7042    with a forward reference.
7043    If its type defines a new named structure or union
7044    or defines an enum, it is valid but we need not do anything here.
7045    Otherwise, it is an error.
7046
7047    C++: may have to grok the declspecs to learn about static,
7048    complain for anonymous unions.  */
7049
7050 void
7051 shadow_tag (declspecs)
7052      tree declspecs;
7053 {
7054   tree t = check_tag_decl (declspecs);
7055
7056   if (t)
7057     maybe_process_partial_specialization (t);
7058
7059   /* This is where the variables in an anonymous union are
7060      declared.  An anonymous union declaration looks like:
7061      union { ... } ;
7062      because there is no declarator after the union, the parser
7063      sends that declaration here.  */
7064   if (t && ANON_AGGR_TYPE_P (t))
7065     {
7066       fixup_anonymous_aggr (t);
7067
7068       if (TYPE_FIELDS (t))
7069         {
7070           tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
7071                                       NULL_TREE);
7072           finish_anon_union (decl);
7073         }
7074     }
7075 }
7076 \f
7077 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
7078
7079 tree
7080 groktypename (typename)
7081      tree typename;
7082 {
7083   if (TREE_CODE (typename) != TREE_LIST)
7084     return typename;
7085   return grokdeclarator (TREE_VALUE (typename),
7086                          TREE_PURPOSE (typename),
7087                          TYPENAME, 0, NULL_TREE);
7088 }
7089
7090 /* Decode a declarator in an ordinary declaration or data definition.
7091    This is called as soon as the type information and variable name
7092    have been parsed, before parsing the initializer if any.
7093    Here we create the ..._DECL node, fill in its type,
7094    and put it on the list of decls for the current context.
7095    The ..._DECL node is returned as the value.
7096
7097    Exception: for arrays where the length is not specified,
7098    the type is left null, to be filled in by `cp_finish_decl'.
7099
7100    Function definitions do not come here; they go to start_function
7101    instead.  However, external and forward declarations of functions
7102    do go through here.  Structure field declarations are done by
7103    grokfield and not through here.  */
7104
7105 tree
7106 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
7107      tree declarator, declspecs;
7108      int initialized;
7109      tree attributes, prefix_attributes;
7110 {
7111   register tree decl;
7112   register tree type, tem;
7113   tree context;
7114   extern int have_extern_spec;
7115   extern int used_extern_spec;
7116   tree attrlist;
7117
7118 #if 0
7119   /* See code below that used this.  */
7120   int init_written = initialized;
7121 #endif
7122
7123   /* This should only be done once on the top most decl.  */
7124   if (have_extern_spec && !used_extern_spec)
7125     {
7126       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"),
7127                                   declspecs);
7128       used_extern_spec = 1;
7129     }
7130
7131   if (attributes || prefix_attributes)
7132     attrlist = build_tree_list (attributes, prefix_attributes);
7133   else
7134     attrlist = NULL_TREE;
7135
7136   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
7137                          attrlist);
7138
7139   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
7140     return NULL_TREE;
7141
7142   type = TREE_TYPE (decl);
7143
7144   if (type == error_mark_node)
7145     return NULL_TREE;
7146
7147   context = DECL_CONTEXT (decl);
7148
7149   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
7150       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
7151     {
7152       /* When parsing the initializer, lookup should use the object's
7153          namespace. */
7154       push_decl_namespace (context);
7155     }
7156
7157   /* We are only interested in class contexts, later. */
7158   if (context && TREE_CODE (context) == NAMESPACE_DECL)
7159     context = NULL_TREE;
7160
7161   if (initialized)
7162     /* Is it valid for this decl to have an initializer at all?
7163        If not, set INITIALIZED to zero, which will indirectly
7164        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7165     switch (TREE_CODE (decl))
7166       {
7167       case TYPE_DECL:
7168         /* typedef foo = bar  means give foo the same type as bar.
7169            We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
7170            Any other case of an initialization in a TYPE_DECL is an error.  */
7171         if (pedantic || list_length (declspecs) > 1)
7172           {
7173             cp_error ("typedef `%D' is initialized", decl);
7174             initialized = 0;
7175           }
7176         break;
7177
7178       case FUNCTION_DECL:
7179         cp_error ("function `%#D' is initialized like a variable", decl);
7180         initialized = 0;
7181         break;
7182
7183       default:
7184         break;
7185       }
7186
7187   if (initialized)
7188     {
7189       if (! toplevel_bindings_p ()
7190           && DECL_EXTERNAL (decl))
7191         cp_warning ("declaration of `%#D' has `extern' and is initialized",
7192                     decl);
7193       DECL_EXTERNAL (decl) = 0;
7194       if (toplevel_bindings_p ())
7195         TREE_STATIC (decl) = 1;
7196
7197       /* Tell `pushdecl' this is an initialized decl
7198          even though we don't yet have the initializer expression.
7199          Also tell `cp_finish_decl' it may store the real initializer.  */
7200       DECL_INITIAL (decl) = error_mark_node;
7201     }
7202
7203 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
7204   SET_DEFAULT_DECL_ATTRIBUTES (decl, attributes);
7205 #endif
7206
7207   /* Set attributes here so if duplicate decl, will have proper attributes.  */
7208   cplus_decl_attributes (decl, attributes, prefix_attributes);
7209
7210   if (context && COMPLETE_TYPE_P (complete_type (context)))
7211     {
7212       push_nested_class (context, 2);
7213
7214       if (TREE_CODE (decl) == VAR_DECL)
7215         {
7216           tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
7217           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
7218             cp_error ("`%#D' is not a static member of `%#T'", decl, context);
7219           else
7220             {
7221               if (DECL_CONTEXT (field) != context)
7222                 {
7223                   cp_pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
7224                               DECL_CONTEXT (field), DECL_NAME (decl),
7225                               context, DECL_NAME (decl));
7226                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
7227                 }
7228               /* Static data member are tricky; an in-class initialization
7229                  still doesn't provide a definition, so the in-class
7230                  declaration will have DECL_EXTERNAL set, but will have an
7231                  initialization.  Thus, duplicate_decls won't warn
7232                  about this situation, and so we check here.  */
7233               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
7234                 cp_error ("duplicate initialization of %D", decl);
7235               if (duplicate_decls (decl, field))
7236                 decl = field;
7237             }
7238         }
7239       else
7240         {
7241           tree field = check_classfn (context, decl);
7242           if (field && duplicate_decls (decl, field))
7243             decl = field;
7244         }
7245
7246       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
7247       DECL_IN_AGGR_P (decl) = 0;
7248       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
7249           || CLASSTYPE_USE_TEMPLATE (context))
7250         {
7251           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
7252           /* [temp.expl.spec] An explicit specialization of a static data
7253              member of a template is a definition if the declaration
7254              includes an initializer; otherwise, it is a declaration.
7255
7256              We check for processing_specialization so this only applies
7257              to the new specialization syntax.  */
7258           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
7259             DECL_EXTERNAL (decl) = 1;
7260         }
7261
7262       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
7263         cp_pedwarn ("declaration of `%#D' outside of class is not definition",
7264                     decl);
7265     }
7266
7267   /* Enter this declaration into the symbol table.  */
7268   tem = maybe_push_decl (decl);
7269
7270   if (processing_template_decl)
7271     tem = push_template_decl (tem);
7272
7273 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7274   /* Tell the back-end to use or not use .common as appropriate.  If we say
7275      -fconserve-space, we want this to save .data space, at the expense of
7276      wrong semantics.  If we say -fno-conserve-space, we want this to
7277      produce errors about redefs; to do this we force variables into the
7278      data segment.  */
7279   DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
7280 #endif
7281
7282   if (! processing_template_decl)
7283     start_decl_1 (tem);
7284
7285   return tem;
7286 }
7287
7288 void
7289 start_decl_1 (decl)
7290      tree decl;
7291 {
7292   tree type = TREE_TYPE (decl);
7293   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
7294
7295   if (type == error_mark_node)
7296     return;
7297
7298   /* If this type of object needs a cleanup, but we're not allowed to
7299      add any more objects with cleanups to the current scope, create a
7300      new binding level.  */
7301   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
7302       && current_binding_level->more_cleanups_ok == 0)
7303     {
7304       keep_next_level (2);
7305       pushlevel (1);
7306       clear_last_expr ();
7307       add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
7308     }
7309
7310   if (initialized)
7311     /* Is it valid for this decl to have an initializer at all?
7312        If not, set INITIALIZED to zero, which will indirectly
7313        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7314     {
7315       /* Don't allow initializations for incomplete types except for
7316          arrays which might be completed by the initialization.  */
7317       if (COMPLETE_TYPE_P (complete_type (type)))
7318         ;                       /* A complete type is ok.  */
7319       else if (TREE_CODE (type) != ARRAY_TYPE)
7320         {
7321           cp_error ("variable `%#D' has initializer but incomplete type",
7322                     decl);
7323           initialized = 0;
7324           type = TREE_TYPE (decl) = error_mark_node;
7325         }
7326       else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7327         {
7328           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
7329             cp_error ("elements of array `%#D' have incomplete type", decl);
7330           /* else we already gave an error in start_decl.  */
7331           initialized = 0;
7332         }
7333     }
7334
7335   if (!initialized
7336       && TREE_CODE (decl) != TYPE_DECL
7337       && TREE_CODE (decl) != TEMPLATE_DECL
7338       && type != error_mark_node
7339       && IS_AGGR_TYPE (type)
7340       && ! DECL_EXTERNAL (decl))
7341     {
7342       if ((! processing_template_decl || ! uses_template_parms (type))
7343           && !COMPLETE_TYPE_P (complete_type (type)))
7344         {
7345           cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
7346                  decl);
7347           /* Change the type so that assemble_variable will give
7348              DECL an rtl we can live with: (mem (const_int 0)).  */
7349           type = TREE_TYPE (decl) = error_mark_node;
7350         }
7351       else
7352         {
7353           /* If any base type in the hierarchy of TYPE needs a constructor,
7354              then we set initialized to 1.  This way any nodes which are
7355              created for the purposes of initializing this aggregate
7356              will live as long as it does.  This is necessary for global
7357              aggregates which do not have their initializers processed until
7358              the end of the file.  */
7359           initialized = TYPE_NEEDS_CONSTRUCTING (type);
7360         }
7361     }
7362
7363   if (! initialized)
7364     DECL_INITIAL (decl) = NULL_TREE;
7365 }
7366
7367 /* Handle initialization of references.
7368    These three arguments are from `cp_finish_decl', and have the
7369    same meaning here that they do there.
7370
7371    Quotes on semantics can be found in ARM 8.4.3.  */
7372
7373 static void
7374 grok_reference_init (decl, type, init)
7375      tree decl, type, init;
7376 {
7377   tree tmp;
7378
7379   if (init == NULL_TREE)
7380     {
7381       if ((DECL_LANG_SPECIFIC (decl) == 0
7382            || DECL_IN_AGGR_P (decl) == 0)
7383           && ! DECL_THIS_EXTERN (decl))
7384         cp_error ("`%D' declared as reference but not initialized", decl);
7385       return;
7386     }
7387
7388   if (init == error_mark_node)
7389     return;
7390
7391   if (TREE_CODE (init) == CONSTRUCTOR)
7392     {
7393       cp_error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
7394       return;
7395     }
7396
7397   if (TREE_CODE (init) == TREE_LIST)
7398     init = build_compound_expr (init);
7399
7400   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
7401     init = convert_from_reference (init);
7402
7403   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
7404       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
7405     {
7406       /* Note: default conversion is only called in very special cases.  */
7407       init = default_conversion (init);
7408     }
7409
7410   /* Convert INIT to the reference type TYPE.  This may involve the
7411      creation of a temporary, whose lifetime must be the same as that
7412      of the reference.  If so, a DECL_STMT for the temporary will be
7413      added just after the DECL_STMT for DECL.  That's why we don't set
7414      DECL_INITIAL for local references (instead assigning to them
7415      explicitly); we need to allow the temporary to be initialized
7416      first.  */
7417   tmp = convert_to_reference
7418     (type, init, CONV_IMPLICIT,
7419      LOOKUP_ONLYCONVERTING|LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND,
7420      decl);
7421
7422   if (tmp == error_mark_node)
7423     return;
7424   else if (tmp != NULL_TREE)
7425     {
7426       init = tmp;
7427       tmp = save_expr (tmp);
7428       if (building_stmt_tree ())
7429         {
7430           /* Initialize the declaration.  */
7431           tmp = build (INIT_EXPR, TREE_TYPE (decl), decl, tmp);
7432           finish_expr_stmt (tmp);
7433         }
7434       else
7435         DECL_INITIAL (decl) = tmp;
7436     }
7437   else
7438     {
7439       cp_error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
7440       return;
7441     }
7442
7443   if (TREE_STATIC (decl) && ! TREE_CONSTANT (DECL_INITIAL (decl)))
7444     {
7445       expand_static_init (decl, DECL_INITIAL (decl));
7446       DECL_INITIAL (decl) = NULL_TREE;
7447     }
7448   return;
7449 }
7450
7451 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7452    mucking with forces it does not comprehend (i.e. initialization with a
7453    constructor).  If we are at global scope and won't go into COMMON, fill
7454    it in with a dummy CONSTRUCTOR to force the variable into .data;
7455    otherwise we can use error_mark_node.  */
7456
7457 static tree
7458 obscure_complex_init (decl, init)
7459      tree decl, init;
7460 {
7461   if (! flag_no_inline && TREE_STATIC (decl))
7462     {
7463       if (extract_init (decl, init))
7464         return NULL_TREE;
7465     }
7466
7467 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7468   if (toplevel_bindings_p () && ! DECL_COMMON (decl))
7469     DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
7470                                  NULL_TREE);
7471   else
7472 #endif
7473     DECL_INITIAL (decl) = error_mark_node;
7474
7475   return init;
7476 }
7477
7478 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7479    array until we finish parsing the initializer.  If that's the
7480    situation we're in, update DECL accordingly.  */
7481
7482 static void
7483 maybe_deduce_size_from_array_init (decl, init)
7484      tree decl;
7485      tree init;
7486 {
7487   tree type = TREE_TYPE (decl);
7488
7489   if (TREE_CODE (type) == ARRAY_TYPE
7490       && TYPE_DOMAIN (type) == NULL_TREE
7491       && TREE_CODE (decl) != TYPE_DECL)
7492     {
7493       int do_default
7494         = (TREE_STATIC (decl)
7495            /* Even if pedantic, an external linkage array
7496               may have incomplete type at first.  */
7497            ? pedantic && ! DECL_EXTERNAL (decl)
7498            : !DECL_EXTERNAL (decl));
7499       tree initializer = init ? init : DECL_INITIAL (decl);
7500       int failure = complete_array_type (type, initializer, do_default);
7501
7502       if (failure == 1)
7503         cp_error ("initializer fails to determine size of `%D'", decl);
7504
7505       if (failure == 2)
7506         {
7507           if (do_default)
7508             cp_error ("array size missing in `%D'", decl);
7509           /* If a `static' var's size isn't known, make it extern as
7510              well as static, so it does not get allocated.  If it's not
7511              `static', then don't mark it extern; finish_incomplete_decl
7512              will give it a default size and it will get allocated.  */
7513           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7514             DECL_EXTERNAL (decl) = 1;
7515         }
7516
7517       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7518           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7519                               integer_zero_node))
7520         cp_error ("zero-size array `%D'", decl);
7521
7522       layout_decl (decl, 0);
7523     }
7524 }
7525
7526 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7527    any appropriate error messages regarding the layout.  */
7528
7529 static void
7530 layout_var_decl (decl)
7531      tree decl;
7532 {
7533   tree type = TREE_TYPE (decl);
7534 #if 0
7535   tree ttype = target_type (type);
7536 #endif
7537
7538   /* If we haven't already layed out this declaration, do so now.
7539      Note that we must not call complete type for an external object
7540      because it's type might involve templates that we are not
7541      supposed to isntantiate yet.  (And it's perfectly legal to say
7542      `extern X x' for some incomplete type `X'.)  */
7543   if (!DECL_EXTERNAL (decl))
7544     complete_type (type);
7545   if (!DECL_SIZE (decl) && COMPLETE_TYPE_P (type))
7546     layout_decl (decl, 0);
7547
7548   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7549     {
7550       /* An automatic variable with an incomplete type: that is an error.
7551          Don't talk about array types here, since we took care of that
7552          message in grokdeclarator.  */
7553       cp_error ("storage size of `%D' isn't known", decl);
7554       TREE_TYPE (decl) = error_mark_node;
7555     }
7556 #if 0
7557   /* Keep this code around in case we later want to control debug info
7558      based on whether a type is "used".  (jason 1999-11-11) */
7559
7560   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7561     /* Let debugger know it should output info for this type.  */
7562     note_debug_info_needed (ttype);
7563
7564   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7565     note_debug_info_needed (DECL_CONTEXT (decl));
7566 #endif
7567
7568   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7569       && DECL_SIZE (decl) != NULL_TREE
7570       && ! TREE_CONSTANT (DECL_SIZE (decl)))
7571     {
7572       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7573         constant_expression_warning (DECL_SIZE (decl));
7574       else
7575         cp_error ("storage size of `%D' isn't constant", decl);
7576     }
7577 }
7578
7579 /* If a local static variable is declared in an inline function, or if
7580    we have a weak definition, we must endeavor to create only one
7581    instance of the variable at link-time.  */
7582
7583 static void
7584 maybe_commonize_var (decl)
7585      tree decl;
7586 {
7587   /* Static data in a function with comdat linkage also has comdat
7588      linkage.  */
7589   if (TREE_STATIC (decl)
7590       /* Don't mess with __FUNCTION__.  */
7591       && ! DECL_ARTIFICIAL (decl)
7592       && current_function_decl
7593       && DECL_CONTEXT (decl) == current_function_decl
7594       && (DECL_THIS_INLINE (current_function_decl)
7595           || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7596       && TREE_PUBLIC (current_function_decl))
7597     {
7598       /* Rather than try to get this right with inlining, we suppress
7599          inlining of such functions.  */
7600       current_function_cannot_inline
7601         = "function with static variable cannot be inline";
7602
7603       /* If flag_weak, we don't need to mess with this, as we can just
7604          make the function weak, and let it refer to its unique local
7605          copy.  This works because we don't allow the function to be
7606          inlined.  */
7607       if (! flag_weak)
7608         {
7609           if (DECL_INTERFACE_KNOWN (current_function_decl))
7610             {
7611               TREE_PUBLIC (decl) = 1;
7612               DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7613             }
7614           else if (DECL_INITIAL (decl) == NULL_TREE
7615                    || DECL_INITIAL (decl) == error_mark_node)
7616             {
7617               TREE_PUBLIC (decl) = 1;
7618               DECL_COMMON (decl) = 1;
7619             }
7620           /* else we lose. We can only do this if we can use common,
7621              which we can't if it has been initialized.  */
7622
7623           if (TREE_PUBLIC (decl))
7624             DECL_ASSEMBLER_NAME (decl)
7625               = build_static_name (current_function_decl, DECL_NAME (decl));
7626           else
7627             {
7628               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7629               cp_warning_at ("  you can work around this by removing the initializer", decl);
7630             }
7631         }
7632     }
7633   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7634     /* Set it up again; we might have set DECL_INITIAL since the last
7635        time.  */
7636     comdat_linkage (decl);
7637 }
7638
7639 /* Issue an error message if DECL is an uninitialized const variable.  */
7640
7641 static void
7642 check_for_uninitialized_const_var (decl)
7643      tree decl;
7644 {
7645   tree type = TREE_TYPE (decl);
7646
7647   /* ``Unless explicitly declared extern, a const object does not have
7648      external linkage and must be initialized. ($8.4; $12.1)'' ARM
7649      7.1.6 */
7650   if (TREE_CODE (decl) == VAR_DECL
7651       && TREE_CODE (type) != REFERENCE_TYPE
7652       && CP_TYPE_CONST_P (type)
7653       && !TYPE_NEEDS_CONSTRUCTING (type)
7654       && !DECL_INITIAL (decl))
7655     cp_error ("uninitialized const `%D'", decl);
7656 }
7657
7658 /* Verify INIT (the initializer for DECL), and record the
7659    initialization in DECL_INITIAL, if appropriate.  Returns a new
7660    value for INIT.  */
7661
7662 static tree
7663 check_initializer (decl, init)
7664      tree decl;
7665      tree init;
7666 {
7667   tree type;
7668
7669   if (TREE_CODE (decl) == FIELD_DECL)
7670     return init;
7671
7672   type = TREE_TYPE (decl);
7673
7674   /* If `start_decl' didn't like having an initialization, ignore it now.  */
7675   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7676     init = NULL_TREE;
7677
7678   /* Check the initializer.  */
7679   if (init)
7680     {
7681       /* Things that are going to be initialized need to have complete
7682          type.  */
7683       TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7684
7685       if (type == error_mark_node)
7686         /* We will have already complained.  */
7687         init = NULL_TREE;
7688       else if (COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
7689         {
7690           cp_error ("variable-sized object `%D' may not be initialized", decl);
7691           init = NULL_TREE;
7692         }
7693       else if (TREE_CODE (type) == ARRAY_TYPE
7694                && !COMPLETE_TYPE_P (TREE_TYPE (type)))
7695         {
7696           cp_error ("elements of array `%#D' have incomplete type", decl);
7697           init = NULL_TREE;
7698         }
7699       else if (!COMPLETE_TYPE_P (type))
7700         {
7701           cp_error ("`%D' has incomplete type", decl);
7702           TREE_TYPE (decl) = error_mark_node;
7703           init = NULL_TREE;
7704         }
7705     }
7706
7707   if (TREE_CODE (decl) == CONST_DECL)
7708     {
7709       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7710
7711       DECL_INITIAL (decl) = init;
7712
7713       /* This will keep us from needing to worry about our obstacks.  */
7714       my_friendly_assert (init != NULL_TREE, 149);
7715       init = NULL_TREE;
7716     }
7717   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7718     {
7719       if (TREE_STATIC (decl))
7720         make_decl_rtl (decl, NULL_PTR, toplevel_bindings_p ());
7721       grok_reference_init (decl, type, init);
7722       init = NULL_TREE;
7723     }
7724   else if (init)
7725     {
7726       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7727         {
7728           if (TREE_CODE (type) == ARRAY_TYPE)
7729             init = digest_init (type, init, (tree *) 0);
7730           else if (TREE_CODE (init) == CONSTRUCTOR
7731                    && TREE_HAS_CONSTRUCTOR (init))
7732             {
7733               if (TYPE_NON_AGGREGATE_CLASS (type))
7734                 {
7735                   cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7736                             decl);
7737                   init = error_mark_node;
7738                 }
7739               else
7740                 goto dont_use_constructor;
7741             }
7742         }
7743       else
7744         {
7745         dont_use_constructor:
7746           if (TREE_CODE (init) != TREE_VEC)
7747             init = store_init_value (decl, init);
7748         }
7749
7750       if (init)
7751         /* We must hide the initializer so that expand_decl
7752            won't try to do something it does not understand.  */
7753         init = obscure_complex_init (decl, init);
7754     }
7755   else if (DECL_EXTERNAL (decl))
7756     ;
7757   else if (TYPE_P (type)
7758            && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
7759     {
7760       tree core_type = strip_array_types (type);
7761
7762       if (! TYPE_NEEDS_CONSTRUCTING (core_type))
7763         {
7764           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
7765             cp_error ("structure `%D' with uninitialized const members", decl);
7766           if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
7767             cp_error ("structure `%D' with uninitialized reference members",
7768                       decl);
7769         }
7770
7771       check_for_uninitialized_const_var (decl);
7772
7773       if (COMPLETE_TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
7774         init = obscure_complex_init (decl, NULL_TREE);
7775
7776     }
7777   else
7778     check_for_uninitialized_const_var (decl);
7779
7780   return init;
7781 }
7782
7783 /* If DECL is not a local variable, give it RTL.  */
7784
7785 static void
7786 make_rtl_for_nonlocal_decl (decl, init, asmspec)
7787      tree decl;
7788      tree init;
7789      const char *asmspec;
7790 {
7791   int toplev;
7792   tree type;
7793
7794   type = TREE_TYPE (decl);
7795   toplev = toplevel_bindings_p ();
7796
7797   /* Handle non-variables up front.  */
7798   if (TREE_CODE (decl) != VAR_DECL)
7799     {
7800       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7801       return;
7802     }
7803
7804   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
7805   if (asmspec)
7806     DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
7807
7808   if (DECL_VIRTUAL_P (decl))
7809     make_decl_rtl (decl, NULL_PTR, toplev);
7810   else if (TREE_READONLY (decl)
7811            && DECL_INITIAL (decl) != NULL_TREE
7812            && DECL_INITIAL (decl) != error_mark_node
7813            && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl)))
7814     {
7815       DECL_INITIAL (decl) = save_expr (DECL_INITIAL (decl));
7816
7817       if (toplev && ! TREE_PUBLIC (decl))
7818         {
7819           /* If this is a static const, change its apparent linkage
7820              if it belongs to a #pragma interface.  */
7821           if (!interface_unknown)
7822             {
7823               TREE_PUBLIC (decl) = 1;
7824               DECL_EXTERNAL (decl) = interface_only;
7825             }
7826           make_decl_rtl (decl, asmspec, toplev);
7827         }
7828       else if (toplev)
7829         rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7830     }
7831   else if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
7832     {
7833       my_friendly_assert (TREE_STATIC (decl), 19990828);
7834
7835       if (init == NULL_TREE
7836 #ifdef DEFAULT_STATIC_DEFS
7837           /* If this code is dead, then users must
7838              explicitly declare static member variables
7839              outside the class def'n as well.  */
7840           && TYPE_NEEDS_CONSTRUCTING (type)
7841 #endif
7842           )
7843         {
7844           DECL_EXTERNAL (decl) = 1;
7845           make_decl_rtl (decl, asmspec, 1);
7846         }
7847       else
7848         rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7849     }
7850   else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == NAMESPACE_DECL
7851            || (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl)))
7852     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7853 }
7854
7855 /* Create RTL for the local static variable DECL.  */
7856
7857 void
7858 make_rtl_for_local_static (decl)
7859      tree decl;
7860 {
7861   const char *asmspec = NULL;
7862
7863   /* If we inlined this variable, we could see it's declaration
7864      again.  */
7865   if (DECL_RTL (decl))
7866     return;
7867
7868   if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
7869     {
7870       /* The only way this situaton can occur is if the
7871          user specified a name for this DECL using the
7872          `attribute' syntax.  */
7873       asmspec = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
7874       DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
7875     }
7876
7877   rest_of_decl_compilation (decl, asmspec, /*top_level=*/0, /*at_end=*/0);
7878 }
7879
7880 /* The old ARM scoping rules injected variables declared in the
7881    initialization statement of a for-statement into the surrounding
7882    scope.  We support this usage, in order to be backward-compatible.
7883    DECL is a just-declared VAR_DECL; if necessary inject its
7884    declaration into the surrounding scope.  */
7885
7886 void
7887 maybe_inject_for_scope_var (decl)
7888      tree decl;
7889 {
7890   if (current_binding_level->is_for_scope)
7891     {
7892       struct binding_level *outer
7893         = current_binding_level->level_chain;
7894
7895       /* Check to see if the same name is already bound at the outer
7896          level, either because it was directly declared, or because a
7897          dead for-decl got preserved.  In either case, the code would
7898          not have been valid under the ARM scope rules, so clear
7899          is_for_scope for the current_binding_level.
7900
7901          Otherwise, we need to preserve the temp slot for decl to last
7902          into the outer binding level.  */
7903
7904       tree outer_binding
7905         = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
7906
7907       if (outer_binding && BINDING_LEVEL (outer_binding) == outer
7908           && (TREE_CODE (BINDING_VALUE (outer_binding))
7909               == VAR_DECL)
7910           && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
7911         {
7912           BINDING_VALUE (outer_binding)
7913             = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
7914           current_binding_level->is_for_scope = 0;
7915         }
7916       else if (DECL_IN_MEMORY_P (decl))
7917         preserve_temp_slots (DECL_RTL (decl));
7918     }
7919 }
7920
7921 /* Generate code to initialize DECL (a local variable).  */
7922
7923 void
7924 initialize_local_var (decl, init, flags)
7925      tree decl;
7926      tree init;
7927      int flags;
7928 {
7929   tree type = TREE_TYPE (decl);
7930
7931   /* If the type is bogus, don't bother initializing the variable.  */
7932   if (type == error_mark_node)
7933     return;
7934
7935   if (DECL_SIZE (decl) == NULL_TREE && !TREE_STATIC (decl))
7936     {
7937       /* If we used it already as memory, it must stay in memory.  */
7938       DECL_INITIAL (decl) = NULL_TREE;
7939       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
7940     }
7941
7942   /* Local statics are handled differently from ordinary automatic
7943      variables.  */
7944   if (TREE_STATIC (decl))
7945     {
7946       if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7947           || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7948         expand_static_init (decl, init);
7949       return;
7950     }
7951
7952   if (DECL_SIZE (decl) && type != error_mark_node)
7953     {
7954       int already_used;
7955
7956       /* Compute and store the initial value.  */
7957       already_used = TREE_USED (decl) || TREE_USED (type);
7958
7959       if (init || TYPE_NEEDS_CONSTRUCTING (type))
7960         {
7961           int saved_stmts_are_full_exprs_p;
7962
7963           emit_line_note (DECL_SOURCE_FILE (decl),
7964                           DECL_SOURCE_LINE (decl));
7965           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p;
7966           stmts_are_full_exprs_p = 1;
7967           finish_expr_stmt (build_aggr_init (decl, init, flags));
7968           stmts_are_full_exprs_p = saved_stmts_are_full_exprs_p;
7969         }
7970
7971       /* Set this to 0 so we can tell whether an aggregate which was
7972          initialized was ever used.  Don't do this if it has a
7973          destructor, so we don't complain about the 'resource
7974          allocation is initialization' idiom.  Now set
7975          attribute((unused)) on types so decls of that type will be
7976          marked used. (see TREE_USED, above.)  */
7977       if (TYPE_NEEDS_CONSTRUCTING (type)
7978           && ! already_used
7979           && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
7980           && DECL_NAME (decl))
7981         TREE_USED (decl) = 0;
7982       else if (already_used)
7983         TREE_USED (decl) = 1;
7984     }
7985 }
7986
7987 /* Generate code to destroy DECL (a local variable).  */
7988
7989 static void
7990 destroy_local_var (decl)
7991      tree decl;
7992 {
7993   tree type = TREE_TYPE (decl);
7994   tree cleanup;
7995
7996   /* Only variables get cleaned up.  */
7997   if (TREE_CODE (decl) != VAR_DECL)
7998     return;
7999
8000   /* And only things with destructors need cleaning up.  */
8001   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
8002     return;
8003
8004   if (TREE_CODE (decl) == VAR_DECL &&
8005       (DECL_EXTERNAL (decl) || TREE_STATIC (decl)))
8006     /* We don't clean up things that aren't defined in this
8007        translation unit, or that need a static cleanup.  The latter
8008        are handled by finish_file.  */
8009     return;
8010
8011   /* Compute the cleanup.  */
8012   cleanup = maybe_build_cleanup (decl);
8013
8014   /* Record the cleanup required for this declaration.  */
8015   if (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node
8016       && cleanup)
8017     finish_decl_cleanup (decl, cleanup);
8018 }
8019
8020 /* Let the back-end know about DECL.  */
8021
8022 void
8023 emit_local_var (decl)
8024      tree decl;
8025 {
8026   /* Create RTL for this variable.  */
8027   if (DECL_RTL (decl))
8028     /* Only a RESULT_DECL should have non-NULL RTL when arriving here.
8029        All other local variables are assigned RTL in this function.  */
8030     my_friendly_assert (TREE_CODE (decl) == RESULT_DECL,
8031                         19990828);
8032   else
8033     {
8034       if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
8035         /* The user must have specified an assembler name for this
8036            variable.  Set that up now.  */
8037         rest_of_decl_compilation
8038           (decl, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
8039            /*top_level=*/0, /*at_end=*/0);
8040       else
8041         expand_decl (decl);
8042     }
8043
8044   /* Actually do the initialization.  */
8045   if (stmts_are_full_exprs_p)
8046     expand_start_target_temps ();
8047
8048   expand_decl_init (decl);
8049
8050   if (stmts_are_full_exprs_p)
8051     expand_end_target_temps ();
8052 }
8053
8054 /* Finish processing of a declaration;
8055    install its line number and initial value.
8056    If the length of an array type is not known before,
8057    it must be determined now, from the initial value, or it is an error.
8058
8059    INIT0 holds the value of an initializer that should be allowed to escape
8060    the normal rules.
8061
8062    FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
8063    if the (init) syntax was used.  */
8064
8065 void
8066 cp_finish_decl (decl, init, asmspec_tree, flags)
8067      tree decl, init;
8068      tree asmspec_tree;
8069      int flags;
8070 {
8071   register tree type;
8072   tree ttype = NULL_TREE;
8073   const char *asmspec = NULL;
8074   int was_readonly = 0;
8075
8076   if (! decl)
8077     {
8078       if (init)
8079         error ("assignment (not initialization) in declaration");
8080       return;
8081     }
8082
8083   /* If a name was specified, get the string.  */
8084   if (asmspec_tree)
8085       asmspec = TREE_STRING_POINTER (asmspec_tree);
8086
8087   if (init && TREE_CODE (init) == NAMESPACE_DECL)
8088     {
8089       cp_error ("cannot initialize `%D' to namespace `%D'",
8090                 decl, init);
8091       init = NULL_TREE;
8092     }
8093
8094   if (current_class_type
8095       && CP_DECL_CONTEXT (decl) == current_class_type
8096       && TYPE_BEING_DEFINED (current_class_type)
8097       && (DECL_INITIAL (decl) || init))
8098     DECL_DEFINED_IN_CLASS_P (decl) = 1;
8099
8100   if (TREE_CODE (decl) == VAR_DECL
8101       && DECL_CONTEXT (decl)
8102       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
8103       && DECL_CONTEXT (decl) != current_namespace
8104       && init)
8105     {
8106       /* Leave the namespace of the object. */
8107       pop_decl_namespace ();
8108     }
8109
8110   type = TREE_TYPE (decl);
8111
8112   if (type == error_mark_node)
8113     return;
8114
8115   /* Add this declaration to the statement-tree.  */
8116   if (building_stmt_tree () && at_function_scope_p ())
8117     add_decl_stmt (decl);
8118
8119   if (TYPE_HAS_MUTABLE_P (type))
8120     TREE_READONLY (decl) = 0;
8121
8122   if (processing_template_decl)
8123     {
8124       if (init && DECL_INITIAL (decl))
8125         DECL_INITIAL (decl) = init;
8126       goto finish_end0;
8127     }
8128
8129   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
8130   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
8131
8132   /* Take care of TYPE_DECLs up front.  */
8133   if (TREE_CODE (decl) == TYPE_DECL)
8134     {
8135       if (init && DECL_INITIAL (decl))
8136         {
8137           /* typedef foo = bar; store the type of bar as the type of foo.  */
8138           TREE_TYPE (decl) = type = TREE_TYPE (init);
8139           DECL_INITIAL (decl) = init = NULL_TREE;
8140         }
8141       if (type != error_mark_node
8142           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
8143         {
8144           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
8145             cp_warning ("shadowing previous type declaration of `%#D'", decl);
8146           set_identifier_type_value (DECL_NAME (decl), type);
8147           CLASSTYPE_GOT_SEMICOLON (type) = 1;
8148         }
8149       GNU_xref_decl (current_function_decl, decl);
8150
8151       /* If we have installed this as the canonical typedef for this
8152          type, and that type has not been defined yet, delay emitting
8153          the debug information for it, as we will emit it later.  */
8154       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
8155           && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
8156         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
8157
8158       rest_of_decl_compilation (decl, NULL_PTR,
8159                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
8160       goto finish_end;
8161     }
8162
8163   if (TREE_CODE (decl) != FUNCTION_DECL)
8164     ttype = target_type (type);
8165
8166   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
8167       && TYPE_NEEDS_CONSTRUCTING (type))
8168     {
8169       /* Currently, GNU C++ puts constants in text space, making them
8170          impossible to initialize.  In the future, one would hope for
8171          an operating system which understood the difference between
8172          initialization and the running of a program.  */
8173       was_readonly = 1;
8174       TREE_READONLY (decl) = 0;
8175     }
8176
8177   if (TREE_CODE (decl) == FIELD_DECL && asmspec)
8178     {
8179       /* This must override the asm specifier which was placed by
8180          grokclassfn.  Lay this out fresh.  */
8181       DECL_RTL (TREE_TYPE (decl)) = NULL_RTX;
8182       DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
8183       make_decl_rtl (decl, asmspec, 0);
8184     }
8185
8186   /* Deduce size of array from initialization, if not already known.  */
8187   maybe_deduce_size_from_array_init (decl, init);
8188   init = check_initializer (decl, init);
8189
8190   GNU_xref_decl (current_function_decl, decl);
8191
8192   if (TREE_CODE (decl) == VAR_DECL)
8193     layout_var_decl (decl);
8194
8195   /* Output the assembler code and/or RTL code for variables and functions,
8196      unless the type is an undefined structure or union.
8197      If not, it will get done when the type is completed.  */
8198   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
8199       || TREE_CODE (decl) == RESULT_DECL)
8200     {
8201       if (TREE_CODE (decl) == VAR_DECL)
8202         maybe_commonize_var (decl);
8203
8204       make_rtl_for_nonlocal_decl (decl, init, asmspec);
8205
8206       if (TREE_CODE (type) == FUNCTION_TYPE
8207           || TREE_CODE (type) == METHOD_TYPE)
8208         abstract_virtuals_error (decl,
8209                                  strip_array_types (TREE_TYPE (type)));
8210       else
8211         abstract_virtuals_error (decl, strip_array_types (type));
8212
8213       if (TREE_CODE (decl) == FUNCTION_DECL)
8214         ;
8215       else if (DECL_EXTERNAL (decl)
8216                && ! (DECL_LANG_SPECIFIC (decl)
8217                      && DECL_NOT_REALLY_EXTERN (decl)))
8218         {
8219           if (init)
8220             DECL_INITIAL (decl) = init;
8221         }
8222       else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
8223         {
8224           /* This is a local declaration.  */
8225           if (doing_semantic_analysis_p ())
8226             maybe_inject_for_scope_var (decl);
8227           /* Initialize the local variable.  But, if we're building a
8228              statement-tree, we'll do the initialization when we
8229              expand the tree.  */
8230           if (processing_template_decl)
8231             {
8232               if (init || DECL_INITIAL (decl) == error_mark_node)
8233                 DECL_INITIAL (decl) = init;
8234             }
8235           else
8236             {
8237               /* If we're not building RTL, then we need to do so
8238                  now.  */
8239               if (!building_stmt_tree ())
8240                 emit_local_var (decl);
8241               /* Initialize the variable.  */
8242               initialize_local_var (decl, init, flags);
8243               /* Clean up the variable.  */
8244               destroy_local_var (decl);
8245             }
8246         }
8247       else if (TREE_STATIC (decl) && type != error_mark_node)
8248         {
8249           /* Cleanups for static variables are handled by `finish_file'.  */
8250           if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
8251               || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8252             expand_static_init (decl, init);
8253         }
8254     finish_end0:
8255
8256       /* Undo call to `pushclass' that was done in `start_decl'
8257          due to initialization of qualified member variable.
8258          I.e., Foo::x = 10;  */
8259       {
8260         tree context = CP_DECL_CONTEXT (decl);
8261         if (context
8262             && TYPE_P (context)
8263             && (TREE_CODE (decl) == VAR_DECL
8264                 /* We also have a pushclass done that we need to undo here
8265                    if we're at top level and declare a method.  */
8266                 || TREE_CODE (decl) == FUNCTION_DECL)
8267             /* If size hasn't been set, we're still defining it,
8268                and therefore inside the class body; don't pop
8269                the binding level..  */
8270             && COMPLETE_TYPE_P (context)
8271             && context == current_class_type)
8272           pop_nested_class ();
8273       }
8274     }
8275
8276  finish_end:
8277
8278   if (was_readonly)
8279     TREE_READONLY (decl) = 1;
8280 }
8281
8282 /* This is here for a midend callback from c-common.c */
8283
8284 void
8285 finish_decl (decl, init, asmspec_tree)
8286      tree decl, init;
8287      tree asmspec_tree;
8288 {
8289   cp_finish_decl (decl, init, asmspec_tree, 0);
8290 }
8291
8292 /* Returns a declaration for a VAR_DECL as if:
8293
8294      extern "C" TYPE NAME;
8295
8296    had been seen.  Used to create compiler-generated global
8297    variables.  */
8298
8299 tree
8300 declare_global_var (name, type)
8301      tree name;
8302      tree type;
8303 {
8304   tree decl;
8305
8306   push_to_top_level ();
8307   decl = build_decl (VAR_DECL, name, type);
8308   TREE_PUBLIC (decl) = 1;
8309   DECL_EXTERNAL (decl) = 1;
8310   DECL_ARTIFICIAL (decl) = 1;
8311   pushdecl (decl);
8312   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
8313   pop_from_top_level ();
8314
8315   return decl;
8316 }
8317
8318 /* Returns a pointer to the `atexit' function.  Note that if
8319    FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
8320    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
8321
8322 static tree
8323 get_atexit_node ()
8324 {
8325   tree atexit_fndecl;
8326   tree arg_types;
8327   tree fn_type;
8328   tree fn_ptr_type;
8329   const char *name;
8330
8331   if (atexit_node)
8332     return atexit_node;
8333
8334   if (flag_use_cxa_atexit)
8335     {
8336       /* The declaration for `__cxa_atexit' is:
8337
8338            int __cxa_atexit (void (*)(void *), void *, void *)
8339
8340          We build up the argument types and then then function type
8341          itself.  */
8342
8343       /* First, build the pointer-to-function type for the first
8344          argument.  */
8345       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8346       fn_type = build_function_type (void_type_node, arg_types);
8347       fn_ptr_type = build_pointer_type (fn_type);
8348       /* Then, build the rest of the argument types.  */
8349       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8350       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
8351       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
8352       /* And the final __cxa_atexit type.  */
8353       fn_type = build_function_type (integer_type_node, arg_types);
8354       fn_ptr_type = build_pointer_type (fn_type);
8355       name = "__cxa_atexit";
8356     }
8357   else
8358     {
8359       /* The declaration for `atexit' is:
8360
8361            int atexit (void (*)());
8362
8363          We build up the argument types and then then function type
8364          itself.  */
8365       fn_type = build_function_type (void_type_node, void_list_node);
8366       fn_ptr_type = build_pointer_type (fn_type);
8367       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
8368       /* Build the final atexit type.  */
8369       fn_type = build_function_type (integer_type_node, arg_types);
8370       name = "atexit";
8371     }
8372
8373   /* Now, build the function declaration.  */
8374   push_lang_context (lang_name_c);
8375   atexit_fndecl = build_library_fn_ptr (name, fn_type);
8376   mark_used (atexit_fndecl);
8377   pop_lang_context ();
8378   atexit_node = default_conversion (atexit_fndecl);
8379
8380   return atexit_node;
8381 }
8382
8383 /* Returns the __dso_handle VAR_DECL.  */
8384
8385 static tree
8386 get_dso_handle_node ()
8387 {
8388   if (dso_handle_node)
8389     return dso_handle_node;
8390
8391   /* Declare the variable.  */
8392   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8393                                         ptr_type_node);
8394
8395   return dso_handle_node;
8396 }
8397
8398 /* Begin a new function with internal linkage whose job will be simply
8399    to destroy some particular variable.  */
8400
8401 static tree
8402 start_cleanup_fn ()
8403 {
8404   static int counter = 0;
8405   int old_interface_unknown = interface_unknown;
8406   char name[32];
8407   tree parmtypes;
8408   tree fntype;
8409   tree fndecl;
8410
8411   push_to_top_level ();
8412
8413   /* No need to mangle this.  */
8414   push_lang_context (lang_name_c);
8415
8416   interface_unknown = 1;
8417
8418   /* Build the parameter-types.  */
8419   parmtypes = void_list_node;
8420   /* Functions passed to __cxa_atexit take an additional parameter.
8421      We'll just ignore it.  After we implement the new calling
8422      convention for destructors, we can eliminate the use of
8423      additional cleanup functions entirely in the -fnew-abi case.  */
8424   if (flag_use_cxa_atexit)
8425     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8426   /* Build the function type itself.  */
8427   fntype = build_function_type (void_type_node, parmtypes);
8428   /* Build the name of the function.  */
8429   sprintf (name, "__tcf_%d", counter++);
8430   /* Build the function declaration.  */
8431   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8432   /* It's a function with internal linkage, generated by the
8433      compiler.  */
8434   TREE_PUBLIC (fndecl) = 0;
8435   DECL_ARTIFICIAL (fndecl) = 1;
8436   /* Build the parameter.  */
8437   if (flag_use_cxa_atexit)
8438     {
8439       tree parmdecl;
8440
8441       parmdecl = build_decl (PARM_DECL, NULL_TREE, ptr_type_node);
8442       DECL_CONTEXT (parmdecl) = fndecl;
8443       DECL_ARG_TYPE (parmdecl) = ptr_type_node;
8444       TREE_USED (parmdecl) = 1;
8445       DECL_ARGUMENTS (fndecl) = parmdecl;
8446     }
8447
8448   pushdecl (fndecl);
8449   start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8450   do_pushlevel ();
8451
8452   interface_unknown = old_interface_unknown;
8453
8454   pop_lang_context ();
8455
8456   return current_function_decl;
8457 }
8458
8459 /* Finish the cleanup function begun by start_cleanup_fn.  */
8460
8461 static void
8462 end_cleanup_fn ()
8463 {
8464   do_poplevel ();
8465
8466   expand_body (finish_function (0));
8467
8468   pop_from_top_level ();
8469 }
8470
8471 /* Generate code to handle the destruction of DECL, an object with
8472    static storage duration.  */
8473
8474 void
8475 register_dtor_fn (decl)
8476      tree decl;
8477 {
8478   tree cleanup;
8479   tree compound_stmt;
8480   tree args;
8481   tree fcall;
8482
8483   int saved_flag_access_control;
8484
8485   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8486     return;
8487
8488   /* Call build_cleanup before we enter the anonymous function so that
8489      any access checks will be done relative to the current scope,
8490      rather than the scope of the anonymous function.  */
8491   build_cleanup (decl);
8492
8493   /* Now start the function.  */
8494   cleanup = start_cleanup_fn ();
8495
8496   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
8497      to the original function, rather than the anonymous one.  That
8498      will make the back-end think that nested functions are in use,
8499      which causes confusion.  */
8500   saved_flag_access_control = flag_access_control;
8501   flag_access_control = 0;
8502   fcall = build_cleanup (decl);
8503   flag_access_control = saved_flag_access_control;
8504
8505   /* Create the body of the anonymous function.  */
8506   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8507   finish_expr_stmt (fcall);
8508   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8509   end_cleanup_fn ();
8510
8511   /* Call atexit with the cleanup function.  */
8512   mark_addressable (cleanup);
8513   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8514   if (flag_use_cxa_atexit)
8515     {
8516       args = tree_cons (NULL_TREE, get_dso_handle_node (), NULL_TREE);
8517       args = tree_cons (NULL_TREE, null_pointer_node, args);
8518       args = tree_cons (NULL_TREE, cleanup, args);
8519     }
8520   else
8521     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8522   finish_expr_stmt (build_function_call (get_atexit_node (), args));
8523 }
8524
8525 void
8526 expand_static_init (decl, init)
8527      tree decl;
8528      tree init;
8529 {
8530   tree oldstatic = value_member (decl, static_aggregates);
8531
8532   if (oldstatic)
8533     {
8534       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8535         cp_error ("multiple initializations given for `%D'", decl);
8536     }
8537   else if (! toplevel_bindings_p ())
8538     {
8539       /* Emit code to perform this initialization but once.  */
8540       tree temp;
8541       tree if_stmt;
8542       tree then_clause;
8543       tree assignment;
8544       tree temp_init;
8545
8546       /* Emit code to perform this initialization but once.  This code
8547          looks like:
8548
8549            static int temp = 0;
8550            if (!temp) {
8551              // Do initialization.
8552              temp = 1;
8553              // Register variable for destruction at end of program.
8554            }
8555
8556          Note that the `temp' variable is only set to 1 *after* the
8557          initialization is complete.  This ensures that an exception,
8558          thrown during the construction, will cause the variable to
8559          reinitialized when we pass through this code again, as per:
8560
8561            [stmt.dcl]
8562
8563            If the initialization exits by throwing an exception, the
8564            initialization is not complete, so it will be tried again
8565            the next time control enters the declaration.
8566
8567          In theory, this process should be thread-safe, too; multiple
8568          threads should not be able to initialize the variable more
8569          than once.  We don't yet attempt to ensure thread-safety.  */
8570       temp = get_temp_name (integer_type_node, 1);
8571       rest_of_decl_compilation (temp, NULL_PTR, 0, 0);
8572
8573       /* Begin the conditional initialization.  */
8574       if_stmt = begin_if_stmt ();
8575       finish_if_stmt_cond (build_binary_op (EQ_EXPR, temp,
8576                                             integer_zero_node),
8577                            if_stmt);
8578       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8579
8580       /* Do the initialization itself.  */
8581       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8582           || (init && TREE_CODE (init) == TREE_LIST))
8583         assignment = build_aggr_init (decl, init, 0);
8584       else if (init)
8585         /* The initialization we're doing here is just a bitwise
8586            copy.  */
8587         assignment = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
8588       else
8589         assignment = NULL_TREE;
8590
8591       /* Once the assignment is complete, set TEMP to 1.  Since the
8592          construction of the static object is complete at this point,
8593          we want to make sure TEMP is set to 1 even if a temporary
8594          constructed during the initialization throws an exception
8595          when it is destroyed.  So, we combine the initialization and
8596          the assignment to TEMP into a single expression, ensuring
8597          that when we call finish_expr_stmt the cleanups will not be
8598          run until after TEMP is set to 1.  */
8599       temp_init = build_modify_expr (temp, NOP_EXPR, integer_one_node);
8600       if (assignment)
8601         {
8602           assignment = tree_cons (NULL_TREE, assignment,
8603                                   build_tree_list (NULL_TREE,
8604                                                    temp_init));
8605           assignment = build_compound_expr (assignment);
8606         }
8607       else
8608         assignment = temp_init;
8609       finish_expr_stmt (assignment);
8610
8611       /* Use atexit to register a function for destroying this static
8612          variable.  */
8613       register_dtor_fn (decl);
8614
8615       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8616       finish_then_clause (if_stmt);
8617       finish_if_stmt ();
8618     }
8619   else
8620     static_aggregates = tree_cons (init, decl, static_aggregates);
8621 }
8622
8623 /* Finish the declaration of a catch-parameter.  */
8624
8625 tree
8626 start_handler_parms (declspecs, declarator)
8627      tree declspecs;
8628      tree declarator;
8629 {
8630   tree decl;
8631   if (declspecs)
8632     {
8633       decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8634                              1, NULL_TREE);
8635       if (decl == NULL_TREE)
8636         error ("invalid catch parameter");
8637     }
8638   else
8639     decl = NULL_TREE;
8640
8641   return decl;
8642 }
8643
8644 \f
8645 /* Make TYPE a complete type based on INITIAL_VALUE.
8646    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8647    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
8648
8649 int
8650 complete_array_type (type, initial_value, do_default)
8651      tree type, initial_value;
8652      int do_default;
8653 {
8654   register tree maxindex = NULL_TREE;
8655   int value = 0;
8656
8657   if (initial_value)
8658     {
8659       /* Note MAXINDEX  is really the maximum index,
8660          one less than the size.  */
8661       if (TREE_CODE (initial_value) == STRING_CST)
8662         {
8663           int eltsize
8664             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8665           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8666                                    / eltsize) - 1, 0);
8667         }
8668       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8669         {
8670           tree elts = CONSTRUCTOR_ELTS (initial_value);
8671
8672           maxindex = ssize_int (-1);
8673           for (; elts; elts = TREE_CHAIN (elts))
8674             {
8675               if (TREE_PURPOSE (elts))
8676                 maxindex = TREE_PURPOSE (elts);
8677               else
8678                 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
8679             }
8680           maxindex = copy_node (maxindex);
8681         }
8682       else
8683         {
8684           /* Make an error message unless that happened already.  */
8685           if (initial_value != error_mark_node)
8686             value = 1;
8687           else
8688             initial_value = NULL_TREE;
8689
8690           /* Prevent further error messages.  */
8691           maxindex = build_int_2 (0, 0);
8692         }
8693     }
8694
8695   if (!maxindex)
8696     {
8697       if (do_default)
8698         maxindex = build_int_2 (0, 0);
8699       value = 2;
8700     }
8701
8702   if (maxindex)
8703     {
8704       tree itype;
8705       tree domain;
8706
8707       domain = build_index_type (maxindex);
8708       TYPE_DOMAIN (type) = domain;
8709
8710       if (! TREE_TYPE (maxindex))
8711         TREE_TYPE (maxindex) = domain;
8712       if (initial_value)
8713         itype = TREE_TYPE (initial_value);
8714       else
8715         itype = NULL;
8716       if (itype && !TYPE_DOMAIN (itype))
8717         TYPE_DOMAIN (itype) = domain;
8718       /* The type of the main variant should never be used for arrays
8719          of different sizes.  It should only ever be completed with the
8720          size of the array.  */
8721       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8722         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8723     }
8724
8725   /* Lay out the type now that we can get the real answer.  */
8726
8727   layout_type (type);
8728
8729   return value;
8730 }
8731 \f
8732 /* Return zero if something is declared to be a member of type
8733    CTYPE when in the context of CUR_TYPE.  STRING is the error
8734    message to print in that case.  Otherwise, quietly return 1.  */
8735
8736 static int
8737 member_function_or_else (ctype, cur_type, flags)
8738      tree ctype, cur_type;
8739      enum overload_flags flags;
8740 {
8741   if (ctype && ctype != cur_type)
8742     {
8743       if (flags == DTOR_FLAG)
8744         error ("destructor for alien class `%s' cannot be a member",
8745                TYPE_NAME_STRING (ctype));
8746       else
8747         error ("constructor for alien class `%s' cannot be a member",
8748                TYPE_NAME_STRING (ctype));
8749       return 0;
8750     }
8751   return 1;
8752 }
8753 \f
8754 /* Subroutine of `grokdeclarator'.  */
8755
8756 /* Generate errors possibly applicable for a given set of specifiers.
8757    This is for ARM $7.1.2.  */
8758
8759 static void
8760 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8761      tree object;
8762      const char *type;
8763      int virtualp, quals, friendp, raises, inlinep;
8764 {
8765   if (virtualp)
8766     cp_error ("`%D' declared as a `virtual' %s", object, type);
8767   if (inlinep)
8768     cp_error ("`%D' declared as an `inline' %s", object, type);
8769   if (quals)
8770     cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8771               object, type);
8772   if (friendp)
8773     cp_error_at ("`%D' declared as a friend", object);
8774   if (raises)
8775     cp_error_at ("`%D' declared with an exception specification", object);
8776 }
8777
8778 /* CTYPE is class type, or null if non-class.
8779    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8780    or METHOD_TYPE.
8781    DECLARATOR is the function's name.
8782    VIRTUALP is truthvalue of whether the function is virtual or not.
8783    FLAGS are to be passed through to `grokclassfn'.
8784    QUALS are qualifiers indicating whether the function is `const'
8785    or `volatile'.
8786    RAISES is a list of exceptions that this function can raise.
8787    CHECK is 1 if we must find this method in CTYPE, 0 if we should
8788    not look, and -1 if we should not call `grokclassfn' at all.
8789
8790    Returns `NULL_TREE' if something goes wrong, after issuing
8791    applicable error messages.  */
8792
8793 static tree
8794 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8795             raises, check, friendp, publicp, inlinep, funcdef_flag,
8796             template_count, in_namespace)
8797      tree ctype, type;
8798      tree declarator;
8799      tree orig_declarator;
8800      int virtualp;
8801      enum overload_flags flags;
8802      tree quals, raises;
8803      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8804      tree in_namespace;
8805 {
8806   tree cname, decl;
8807   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8808   int has_default_arg = 0;
8809   tree t;
8810
8811   if (ctype)
8812     cname = TREE_CODE (TYPE_NAME (ctype)) == TYPE_DECL
8813       ? TYPE_IDENTIFIER (ctype) : TYPE_NAME (ctype);
8814   else
8815     cname = NULL_TREE;
8816
8817   if (raises)
8818     {
8819       type = build_exception_variant (type, raises);
8820     }
8821
8822   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8823   /* Propagate volatile out from type to decl. */
8824   if (TYPE_VOLATILE (type))
8825     TREE_THIS_VOLATILE (decl) = 1;
8826
8827   /* If this decl has namespace scope, set that up.  */
8828   if (in_namespace)
8829     set_decl_namespace (decl, in_namespace, friendp);
8830   else if (publicp && ! ctype)
8831     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8832
8833   /* `main' and builtins have implicit 'C' linkage.  */
8834   if ((MAIN_NAME_P (declarator)
8835        || (IDENTIFIER_LENGTH (declarator) > 10
8836            && IDENTIFIER_POINTER (declarator)[0] == '_'
8837            && IDENTIFIER_POINTER (declarator)[1] == '_'
8838            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8839       && current_lang_name == lang_name_cplusplus
8840       && ctype == NULL_TREE
8841       /* NULL_TREE means global namespace.  */
8842       && DECL_CONTEXT (decl) == NULL_TREE)
8843     DECL_LANGUAGE (decl) = lang_c;
8844
8845   /* Should probably propagate const out from type to decl I bet (mrs).  */
8846   if (staticp)
8847     {
8848       DECL_STATIC_FUNCTION_P (decl) = 1;
8849       DECL_CONTEXT (decl) = ctype;
8850     }
8851
8852   if (ctype)
8853     DECL_CONTEXT (decl) = ctype;
8854
8855   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8856     {
8857       if (processing_template_decl)
8858         error ("cannot declare `::main' to be a template");
8859       if (inlinep)
8860         error ("cannot declare `::main' to be inline");
8861       else if (! publicp)
8862         error ("cannot declare `::main' to be static");
8863       inlinep = 0;
8864       publicp = 1;
8865     }
8866
8867   /* Members of anonymous types and local classes have no linkage; make
8868      them internal.  */
8869   if (ctype && (ANON_AGGRNAME_P (TYPE_IDENTIFIER (ctype))
8870                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
8871     publicp = 0;
8872
8873   if (publicp)
8874     {
8875       /* [basic.link]: A name with no linkage (notably, the name of a class
8876          or enumeration declared in a local scope) shall not be used to
8877          declare an entity with linkage.
8878
8879          Only check this for public decls for now.  */
8880       t = no_linkage_check (TREE_TYPE (decl));
8881       if (t)
8882         {
8883           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8884             {
8885               if (DECL_EXTERN_C_P (decl))
8886                 /* Allow this; it's pretty common in C.  */;
8887               else
8888                 cp_pedwarn ("non-local function `%#D' uses anonymous type",
8889                             decl);
8890             }
8891           else
8892             cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8893                         decl, t);
8894         }
8895     }
8896
8897   TREE_PUBLIC (decl) = publicp;
8898   if (! publicp)
8899     {
8900       DECL_INTERFACE_KNOWN (decl) = 1;
8901       DECL_NOT_REALLY_EXTERN (decl) = 1;
8902     }
8903
8904   if (inlinep)
8905     DECL_THIS_INLINE (decl) = DECL_INLINE (decl) = 1;
8906
8907   DECL_EXTERNAL (decl) = 1;
8908   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
8909     {
8910       cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8911                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
8912       quals = NULL_TREE;
8913     }
8914
8915   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
8916     grok_op_properties (decl, virtualp, check < 0);
8917
8918   if (ctype && decl_function_context (decl))
8919     DECL_NO_STATIC_CHAIN (decl) = 1;
8920
8921   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
8922     if (TREE_PURPOSE (t)
8923         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
8924       {
8925         has_default_arg = 1;
8926         break;
8927       }
8928
8929   if (friendp
8930       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
8931     {
8932       if (funcdef_flag)
8933         cp_error
8934           ("defining explicit specialization `%D' in friend declaration",
8935            orig_declarator);
8936       else
8937         {
8938           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8939             {
8940               /* Something like `template <class T> friend void f<T>()'.  */
8941               cp_error ("invalid use of template-id `%D' in declaration of primary template",
8942                         orig_declarator);
8943               return NULL_TREE;
8944             }
8945
8946
8947           /* A friend declaration of the form friend void f<>().  Record
8948              the information in the TEMPLATE_ID_EXPR.  */
8949           SET_DECL_IMPLICIT_INSTANTIATION (decl);
8950           DECL_TEMPLATE_INFO (decl)
8951             = tree_cons (TREE_OPERAND (orig_declarator, 0),
8952                          TREE_OPERAND (orig_declarator, 1),
8953                          NULL_TREE);
8954
8955           if (has_default_arg)
8956             {
8957               cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8958                         decl);
8959               return NULL_TREE;
8960             }
8961
8962           if (inlinep)
8963             {
8964               cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
8965                         decl);
8966               return NULL_TREE;
8967             }
8968         }
8969     }
8970
8971   if (has_default_arg)
8972     add_defarg_fn (decl);
8973
8974   /* Plain overloading: will not be grok'd by grokclassfn.  */
8975   if (! ctype && ! processing_template_decl
8976       && !DECL_EXTERN_C_P (decl)
8977       && (! DECL_USE_TEMPLATE (decl) || name_mangling_version < 1))
8978     set_mangled_name_for_decl (decl);
8979
8980   if (funcdef_flag)
8981     /* Make the init_value nonzero so pushdecl knows this is not
8982        tentative.  error_mark_node is replaced later with the BLOCK.  */
8983     DECL_INITIAL (decl) = error_mark_node;
8984
8985   if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
8986     TREE_NOTHROW (decl) = 1;
8987
8988   /* Caller will do the rest of this.  */
8989   if (check < 0)
8990     return decl;
8991
8992   if (flags == NO_SPECIAL && ctype && constructor_name (cname) == declarator)
8993     DECL_CONSTRUCTOR_P (decl) = 1;
8994
8995   /* Function gets the ugly name, field gets the nice one.  This call
8996      may change the type of the function (because of default
8997      parameters)!  */
8998   if (ctype != NULL_TREE)
8999     grokclassfn (ctype, decl, flags, quals);
9000
9001   decl = check_explicit_specialization (orig_declarator, decl,
9002                                         template_count,
9003                                         2 * (funcdef_flag != 0) +
9004                                         4 * (friendp != 0));
9005   if (decl == error_mark_node)
9006     return NULL_TREE;
9007
9008   if (ctype != NULL_TREE
9009       && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
9010       && check)
9011     {
9012       tree old_decl;
9013
9014       old_decl = check_classfn (ctype, decl);
9015
9016       if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
9017         /* Because grokfndecl is always supposed to return a
9018            FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
9019            here.  We depend on our callers to figure out that its
9020            really a template that's being returned.  */
9021         old_decl = DECL_TEMPLATE_RESULT (old_decl);
9022
9023       if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
9024           && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
9025         {
9026           /* Remove the `this' parm added by grokclassfn.
9027              XXX Isn't this done in start_function, too?  */
9028           revert_static_member_fn (decl);
9029           last_function_parms = TREE_CHAIN (last_function_parms);
9030         }
9031       if (old_decl && DECL_ARTIFICIAL (old_decl))
9032         cp_error ("definition of implicitly-declared `%D'", old_decl);
9033
9034       if (old_decl)
9035         {
9036           /* Since we've smashed OLD_DECL to its
9037              DECL_TEMPLATE_RESULT, we must do the same to DECL.  */
9038           if (TREE_CODE (decl) == TEMPLATE_DECL)
9039             decl = DECL_TEMPLATE_RESULT (decl);
9040
9041           /* Attempt to merge the declarations.  This can fail, in
9042              the case of some illegal specialization declarations.  */
9043           if (!duplicate_decls (decl, old_decl))
9044             cp_error ("no `%#D' member function declared in class `%T'",
9045                       decl, ctype);
9046           return old_decl;
9047         }
9048     }
9049
9050   if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
9051     return NULL_TREE;
9052
9053   if (ctype == NULL_TREE || check)
9054     return decl;
9055
9056   if (virtualp)
9057     {
9058       DECL_VIRTUAL_P (decl) = 1;
9059       if (DECL_VINDEX (decl) == NULL_TREE)
9060         DECL_VINDEX (decl) = error_mark_node;
9061       IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
9062     }
9063
9064   return decl;
9065 }
9066
9067 static tree
9068 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
9069      tree type;
9070      tree declarator;
9071      RID_BIT_TYPE *specbits_in;
9072      int initialized;
9073      int constp;
9074      tree in_namespace;
9075 {
9076   tree decl;
9077   RID_BIT_TYPE specbits;
9078
9079   specbits = *specbits_in;
9080
9081   if (TREE_CODE (type) == OFFSET_TYPE)
9082     {
9083       /* If you declare a static member so that it
9084          can be initialized, the code will reach here.  */
9085       tree basetype = TYPE_OFFSET_BASETYPE (type);
9086       type = TREE_TYPE (type);
9087       decl = build_lang_decl (VAR_DECL, declarator, type);
9088       DECL_CONTEXT (decl) = basetype;
9089       DECL_ASSEMBLER_NAME (decl) = build_static_name (basetype, declarator);
9090     }
9091   else
9092     {
9093       tree context;
9094
9095       if (in_namespace)
9096         context = in_namespace;
9097       else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
9098         context = current_namespace;
9099       else
9100         context = NULL_TREE;
9101
9102       if (processing_template_decl && context)
9103         /* For global variables, declared in a template, we need the
9104            full lang_decl.  */
9105         decl = build_lang_decl (VAR_DECL, declarator, type);
9106       else
9107         decl = build_decl (VAR_DECL, declarator, type);
9108
9109       if (context)
9110         set_decl_namespace (decl, context, 0);
9111
9112       context = DECL_CONTEXT (decl);
9113       if (declarator && context && current_lang_name != lang_name_c)
9114         DECL_ASSEMBLER_NAME (decl) = build_static_name (context, declarator);
9115     }
9116
9117   if (in_namespace)
9118     set_decl_namespace (decl, in_namespace, 0);
9119
9120   if (RIDBIT_SETP (RID_EXTERN, specbits))
9121     {
9122       DECL_THIS_EXTERN (decl) = 1;
9123       DECL_EXTERNAL (decl) = !initialized;
9124     }
9125
9126   /* In class context, static means one per class,
9127      public access, and static storage.  */
9128   if (DECL_CLASS_SCOPE_P (decl))
9129     {
9130       TREE_PUBLIC (decl) = 1;
9131       TREE_STATIC (decl) = 1;
9132       DECL_EXTERNAL (decl) = 0;
9133     }
9134   /* At top level, either `static' or no s.c. makes a definition
9135      (perhaps tentative), and absence of `static' makes it public.  */
9136   else if (toplevel_bindings_p ())
9137     {
9138       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
9139                             && (DECL_THIS_EXTERN (decl) || ! constp));
9140       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
9141     }
9142   /* Not at top level, only `static' makes a static definition.  */
9143   else
9144     {
9145       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
9146       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
9147     }
9148
9149   if (TREE_PUBLIC (decl))
9150     {
9151       /* [basic.link]: A name with no linkage (notably, the name of a class
9152          or enumeration declared in a local scope) shall not be used to
9153          declare an entity with linkage.
9154
9155          Only check this for public decls for now.  */
9156       tree t = no_linkage_check (TREE_TYPE (decl));
9157       if (t)
9158         {
9159           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
9160             /* Ignore for now; `enum { foo } e' is pretty common.  */;
9161           else
9162             cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
9163                         decl, t);
9164         }
9165     }
9166
9167   return decl;
9168 }
9169
9170 /* Create and return a canonical pointer to member function type, for
9171    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
9172
9173 tree
9174 build_ptrmemfunc_type (type)
9175      tree type;
9176 {
9177   tree fields[4];
9178   tree t;
9179   tree u;
9180   tree unqualified_variant = NULL_TREE;
9181
9182   /* If a canonical type already exists for this type, use it.  We use
9183      this method instead of type_hash_canon, because it only does a
9184      simple equality check on the list of field members.  */
9185
9186   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
9187     return t;
9188
9189   /* Make sure that we always have the unqualified pointer-to-member
9190      type first.  */
9191   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9192     unqualified_variant
9193       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
9194
9195   t = make_aggr_type (RECORD_TYPE);
9196   /* Let the front-end know this is a pointer to member function...  */
9197   TYPE_PTRMEMFUNC_FLAG (t) = 1;
9198   /* ... and not really an aggregate.  */
9199   SET_IS_AGGR_TYPE (t, 0);
9200
9201   if (!flag_new_abi)
9202     {
9203       u = make_aggr_type (UNION_TYPE);
9204       SET_IS_AGGR_TYPE (u, 0);
9205       fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9206       fields[1] = build_decl (FIELD_DECL, delta2_identifier,
9207                               delta_type_node);
9208       finish_builtin_type (u, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9209       TYPE_NAME (u) = NULL_TREE;
9210
9211       fields[0] = build_decl (FIELD_DECL, delta_identifier,
9212                               delta_type_node);
9213       fields[1] = build_decl (FIELD_DECL, index_identifier,
9214                               delta_type_node);
9215       fields[2] = build_decl (FIELD_DECL, pfn_or_delta2_identifier, u);
9216       finish_builtin_type (t, "__ptrmemfunc_type", fields, 2, ptr_type_node);
9217     }
9218   else
9219     {
9220       fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9221       fields[1] = build_decl (FIELD_DECL, delta_identifier,
9222                               delta_type_node);
9223       finish_builtin_type (t, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9224     }
9225
9226   /* Zap out the name so that the back-end will give us the debugging
9227      information for this anonymous RECORD_TYPE.  */
9228   TYPE_NAME (t) = NULL_TREE;
9229
9230   /* If this is not the unqualified form of this pointer-to-member
9231      type, set the TYPE_MAIN_VARIANT for this type to be the
9232      unqualified type.  Since they are actually RECORD_TYPEs that are
9233      not variants of each other, we must do this manually.  */
9234   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9235     {
9236       t = build_qualified_type (t, CP_TYPE_QUALS (type));
9237       TYPE_MAIN_VARIANT (t) = unqualified_variant;
9238       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
9239       TYPE_NEXT_VARIANT (unqualified_variant) = t;
9240     }
9241
9242   /* Cache this pointer-to-member type so that we can find it again
9243      later.  */
9244   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
9245
9246   /* Seems to be wanted.  */
9247   CLASSTYPE_GOT_SEMICOLON (t) = 1;
9248
9249   return t;
9250 }
9251
9252 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9253    Check to see that the definition is valid.  Issue appropriate error
9254    messages.  Return 1 if the definition is particularly bad, or 0
9255    otherwise.  */
9256
9257 int
9258 check_static_variable_definition (decl, type)
9259      tree decl;
9260      tree type;
9261 {
9262   /* Motion 10 at San Diego: If a static const integral data member is
9263      initialized with an integral constant expression, the initializer
9264      may appear either in the declaration (within the class), or in
9265      the definition, but not both.  If it appears in the class, the
9266      member is a member constant.  The file-scope definition is always
9267      required.  */
9268   if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
9269     {
9270       cp_error ("invalid in-class initialization of static data member of non-integral type `%T'",
9271                 type);
9272       /* If we just return the declaration, crashes will sometimes
9273          occur.  We therefore return void_type_node, as if this was a
9274          friend declaration, to cause callers to completely ignore
9275          this declaration.  */
9276       return 1;
9277     }
9278   else if (!CP_TYPE_CONST_P (type))
9279     cp_error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9280               decl);
9281   else if (pedantic && !INTEGRAL_TYPE_P (type))
9282     cp_pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
9283
9284   return 0;
9285 }
9286
9287 /* Given the SIZE (i.e., number of elements) in an array, compute an
9288    appropriate index type for the array.  If non-NULL, NAME is the
9289    name of the thing being declared.  */
9290
9291 tree
9292 compute_array_index_type (name, size)
9293      tree name;
9294      tree size;
9295 {
9296   tree itype;
9297
9298   /* The size might be the result of a cast. */
9299   STRIP_TYPE_NOPS (size);
9300
9301   /* It might be a const variable or enumeration constant.  */
9302   size = decl_constant_value (size);
9303
9304   /* If this involves a template parameter, it will be a constant at
9305      instantiation time, but we don't know what the value is yet.
9306      Even if no template parameters are involved, we may an expression
9307      that is not a constant; we don't even simplify `1 + 2' when
9308      processing a template.  */
9309   if (processing_template_decl)
9310     {
9311       /* Resolve a qualified reference to an enumerator or static
9312          const data member of ours.  */
9313       if (TREE_CODE (size) == SCOPE_REF
9314           && TREE_OPERAND (size, 0) == current_class_type)
9315         {
9316           tree t = lookup_field (current_class_type,
9317                                  TREE_OPERAND (size, 1), 0, 0);
9318           if (t)
9319             size = t;
9320         }
9321
9322       return build_index_type (build_min (MINUS_EXPR, sizetype,
9323                                           size, integer_one_node));
9324     }
9325
9326   /* The array bound must be an integer type.  */
9327   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9328       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
9329       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
9330     {
9331       if (name)
9332         cp_error ("size of array `%D' has non-integer type", name);
9333       else
9334         cp_error ("size of array has non-integer type");
9335       size = integer_one_node;
9336     }
9337
9338   /* Normally, the array-bound will be a constant.  */
9339   if (TREE_CONSTANT (size))
9340     {
9341       /* Check to see if the array bound overflowed.  Make that an
9342          error, no matter how generous we're being.  */
9343       int old_flag_pedantic_errors = flag_pedantic_errors;
9344       int old_pedantic = pedantic;
9345       pedantic = flag_pedantic_errors = 1;
9346       constant_expression_warning (size);
9347       pedantic = old_pedantic;
9348       flag_pedantic_errors = old_flag_pedantic_errors;
9349
9350       /* An array must have a positive number of elements.  */
9351       if (INT_CST_LT (size, integer_zero_node))
9352         {
9353           if (name)
9354             cp_error ("size of array `%D' is negative", name);
9355           else
9356             cp_error ("size of array is negative");
9357           size = integer_one_node;
9358         }
9359       /* Except that an extension we allow zero-sized arrays.  We
9360          always allow them in system headers because glibc uses
9361          them.  */
9362       else if (integer_zerop (size) && pedantic && !in_system_header)
9363         {
9364           if (name)
9365             cp_pedwarn ("ISO C++ forbids zero-size array `%D'", name);
9366           else
9367             cp_pedwarn ("ISO C++ forbids zero-size array");
9368         }
9369     }
9370
9371   /* Compute the index of the largest element in the array.  It is
9372      one less than the number of elements in the array.  */
9373   itype
9374     = fold (build_binary_op (MINUS_EXPR,
9375                              cp_convert (ssizetype, size),
9376                              cp_convert (ssizetype,
9377                                          integer_one_node)));
9378
9379   /* Check for variable-sized arrays.  We allow such things as an
9380      extension, even though they are not allowed in ANSI/ISO C++.  */
9381   if (!TREE_CONSTANT (itype))
9382     {
9383       if (pedantic)
9384         {
9385           if (name)
9386             cp_pedwarn ("ISO C++ forbids variable-size array `%D'",
9387                         name);
9388           else
9389             cp_pedwarn ("ISO C++ forbids variable-size array");
9390         }
9391
9392       /* Create a variable-sized array index type.  */
9393       itype = variable_size (itype);
9394     }
9395   /* Make sure that there was no overflow when creating to a signed
9396      index type.  (For example, on a 32-bit machine, an array with
9397      size 2^32 - 1 is too big.)  */
9398   else if (TREE_OVERFLOW (itype))
9399     {
9400       error ("overflow in array dimension");
9401       TREE_OVERFLOW (itype) = 0;
9402     }
9403
9404   /* Create and return the appropriate index type.  */
9405   return build_index_type (itype);
9406 }
9407
9408 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9409    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
9410    with this type.  */
9411
9412 static tree
9413 create_array_type_for_decl (name, type, size)
9414      tree name;
9415      tree type;
9416      tree size;
9417 {
9418   tree itype = NULL_TREE;
9419   const char* error_msg;
9420
9421   /* If things have already gone awry, bail now.  */
9422   if (type == error_mark_node || size == error_mark_node)
9423     return error_mark_node;
9424
9425   /* Assume that everything will go OK.  */
9426   error_msg = NULL;
9427
9428   /* There are some types which cannot be array elements.  */
9429   switch (TREE_CODE (type))
9430     {
9431     case VOID_TYPE:
9432       error_msg = "array of void";
9433       break;
9434
9435     case FUNCTION_TYPE:
9436       error_msg = "array of functions";
9437       break;
9438
9439     case REFERENCE_TYPE:
9440       error_msg = "array of references";
9441       break;
9442
9443     case OFFSET_TYPE:
9444       error_msg = "array of data members";
9445       break;
9446
9447     case METHOD_TYPE:
9448       error_msg = "array of function members";
9449       break;
9450
9451     default:
9452       break;
9453     }
9454
9455   /* If something went wrong, issue an error-message and return.  */
9456   if (error_msg)
9457     {
9458       if (name)
9459         cp_error ("declaration of `%D' as %s", name, error_msg);
9460       else
9461         cp_error ("creating %s", error_msg);
9462
9463       return error_mark_node;
9464     }
9465
9466   /* [dcl.array]
9467
9468      The constant expressions that specify the bounds of the arrays
9469      can be omitted only for the first member of the sequence.  */
9470   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9471     {
9472       cp_error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9473                 name);
9474
9475       return error_mark_node;
9476     }
9477
9478   /* Figure out the index type for the array.  */
9479   if (size)
9480     itype = compute_array_index_type (name, size);
9481
9482   return build_cplus_array_type (type, itype);
9483 }
9484
9485 /* Check that it's OK to declare a function with the indicated TYPE.
9486    SFK indicates the kind of special function (if any) that this
9487    function is.  CTYPE is the class of which this function is a
9488    member.  OPTYPE is the type given in a conversion operator
9489    declaration.  Returns the actual return type of the function; that
9490    may be different than TYPE if an error occurs, or for certain
9491    special functions.  */
9492
9493 static tree
9494 check_special_function_return_type (sfk, type, ctype, optype)
9495      special_function_kind sfk;
9496      tree type;
9497      tree ctype;
9498      tree optype;
9499 {
9500   switch (sfk)
9501     {
9502     case sfk_constructor:
9503       if (type)
9504         cp_error ("return type specification for constructor invalid");
9505
9506       /* In the old ABI, we return `this'; in the new ABI we don't
9507          bother.  */
9508       type = flag_new_abi ? void_type_node : build_pointer_type (ctype);
9509       break;
9510
9511     case sfk_destructor:
9512       if (type)
9513         cp_error ("return type specification for destructor invalid");
9514       type = void_type_node;
9515       break;
9516
9517     case sfk_conversion:
9518       if (type && !same_type_p (type, optype))
9519         cp_error ("operator `%T' declared to return `%T'", optype, type);
9520       else if (type)
9521         cp_pedwarn ("return type specified for `operator %T'",  optype);
9522       type = optype;
9523       break;
9524
9525     default:
9526       my_friendly_abort (20000408);
9527       break;
9528     }
9529
9530   return type;
9531 }
9532
9533 /* Given declspecs and a declarator,
9534    determine the name and type of the object declared
9535    and construct a ..._DECL node for it.
9536    (In one case we can return a ..._TYPE node instead.
9537     For invalid input we sometimes return 0.)
9538
9539    DECLSPECS is a chain of tree_list nodes whose value fields
9540     are the storage classes and type specifiers.
9541
9542    DECL_CONTEXT says which syntactic context this declaration is in:
9543      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9544      FUNCDEF for a function definition.  Like NORMAL but a few different
9545       error messages in each case.  Return value may be zero meaning
9546       this definition is too screwy to try to parse.
9547      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
9548       handle member functions (which have FIELD context).
9549       Return value may be zero meaning this definition is too screwy to
9550       try to parse.
9551      PARM for a parameter declaration (either within a function prototype
9552       or before a function body).  Make a PARM_DECL, or return void_type_node.
9553      CATCHPARM for a parameter declaration before a catch clause.
9554      TYPENAME if for a typename (in a cast or sizeof).
9555       Don't make a DECL node; just return the ..._TYPE node.
9556      FIELD for a struct or union field; make a FIELD_DECL.
9557      BITFIELD for a field with specified width.
9558    INITIALIZED is 1 if the decl has an initializer.
9559
9560    ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
9561    normal attributes in TREE_PURPOSE, or NULL_TREE.
9562
9563    In the TYPENAME case, DECLARATOR is really an abstract declarator.
9564    It may also be so in the PARM case, for a prototype where the
9565    argument type is specified but not the name.
9566
9567    This function is where the complicated C meanings of `static'
9568    and `extern' are interpreted.
9569
9570    For C++, if there is any monkey business to do, the function which
9571    calls this one must do it, i.e., prepending instance variables,
9572    renaming overloaded function names, etc.
9573
9574    Note that for this C++, it is an error to define a method within a class
9575    which does not belong to that class.
9576
9577    Except in the case where SCOPE_REFs are implicitly known (such as
9578    methods within a class being redundantly qualified),
9579    declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9580    (class_name::decl_name).  The caller must also deal with this.
9581
9582    If a constructor or destructor is seen, and the context is FIELD,
9583    then the type gains the attribute TREE_HAS_x.  If such a declaration
9584    is erroneous, NULL_TREE is returned.
9585
9586    QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
9587    function, these are the qualifiers to give to the `this' pointer. We
9588    apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9589
9590    May return void_type_node if the declarator turned out to be a friend.
9591    See grokfield for details.  */
9592
9593 tree
9594 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9595      tree declspecs;
9596      tree declarator;
9597      enum decl_context decl_context;
9598      int initialized;
9599      tree attrlist;
9600 {
9601   RID_BIT_TYPE specbits;
9602   int nclasses = 0;
9603   tree spec;
9604   tree type = NULL_TREE;
9605   int longlong = 0;
9606   int constp;
9607   int restrictp;
9608   int volatilep;
9609   int type_quals;
9610   int virtualp, explicitp, friendp, inlinep, staticp;
9611   int explicit_int = 0;
9612   int explicit_char = 0;
9613   int defaulted_int = 0;
9614   tree typedef_decl = NULL_TREE;
9615   const char *name;
9616   tree typedef_type = NULL_TREE;
9617   int funcdef_flag = 0;
9618   enum tree_code innermost_code = ERROR_MARK;
9619   int bitfield = 0;
9620 #if 0
9621   /* See the code below that used this.  */
9622   tree decl_machine_attr = NULL_TREE;
9623 #endif
9624   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9625      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9626   tree init = NULL_TREE;
9627
9628   /* Keep track of what sort of function is being processed
9629      so that we can warn about default return values, or explicit
9630      return values which do not match prescribed defaults.  */
9631   special_function_kind sfk = sfk_none;
9632
9633   tree dname = NULL_TREE;
9634   tree ctype = current_class_type;
9635   tree ctor_return_type = NULL_TREE;
9636   enum overload_flags flags = NO_SPECIAL;
9637   tree quals = NULL_TREE;
9638   tree raises = NULL_TREE;
9639   int template_count = 0;
9640   tree in_namespace = NULL_TREE;
9641   tree inner_attrs;
9642   int ignore_attrs;
9643
9644   RIDBIT_RESET_ALL (specbits);
9645   if (decl_context == FUNCDEF)
9646     funcdef_flag = 1, decl_context = NORMAL;
9647   else if (decl_context == MEMFUNCDEF)
9648     funcdef_flag = -1, decl_context = FIELD;
9649   else if (decl_context == BITFIELD)
9650     bitfield = 1, decl_context = FIELD;
9651
9652   /* Look inside a declarator for the name being declared
9653      and get it as a string, for an error message.  */
9654   {
9655     tree *next = &declarator;
9656     register tree decl;
9657     name = NULL;
9658
9659     while (next && *next)
9660       {
9661         decl = *next;
9662         switch (TREE_CODE (decl))
9663           {
9664           case TREE_LIST:
9665             /* For attributes.  */
9666             next = &TREE_VALUE (decl);
9667             break;
9668
9669           case COND_EXPR:
9670             ctype = NULL_TREE;
9671             next = &TREE_OPERAND (decl, 0);
9672             break;
9673
9674           case BIT_NOT_EXPR:    /* For C++ destructors!  */
9675             {
9676               tree name = TREE_OPERAND (decl, 0);
9677               tree rename = NULL_TREE;
9678
9679               my_friendly_assert (flags == NO_SPECIAL, 152);
9680               flags = DTOR_FLAG;
9681               sfk = sfk_destructor;
9682               if (TREE_CODE (name) == TYPE_DECL)
9683                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9684               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9685               if (ctype == NULL_TREE)
9686                 {
9687                   if (current_class_type == NULL_TREE)
9688                     {
9689                       error ("destructors must be member functions");
9690                       flags = NO_SPECIAL;
9691                     }
9692                   else
9693                     {
9694                       tree t = constructor_name (current_class_name);
9695                       if (t != name)
9696                         rename = t;
9697                     }
9698                 }
9699               else
9700                 {
9701                   tree t = constructor_name (ctype);
9702                   if (t != name)
9703                     rename = t;
9704                 }
9705
9706               if (rename)
9707                 {
9708                   cp_error ("destructor `%T' must match class name `%T'",
9709                             name, rename);
9710                   TREE_OPERAND (decl, 0) = rename;
9711                 }
9712               next = &name;
9713             }
9714             break;
9715
9716           case ADDR_EXPR:       /* C++ reference declaration */
9717             /* Fall through. */
9718           case ARRAY_REF:
9719           case INDIRECT_REF:
9720             ctype = NULL_TREE;
9721             innermost_code = TREE_CODE (decl);
9722             next = &TREE_OPERAND (decl, 0);
9723             break;
9724
9725           case CALL_EXPR:
9726             if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
9727               {
9728                 /* This is actually a variable declaration using
9729                    constructor syntax.  We need to call start_decl and
9730                    cp_finish_decl so we can get the variable
9731                    initialized...  */
9732
9733                 tree attributes, prefix_attributes;
9734
9735                 *next = TREE_OPERAND (decl, 0);
9736                 init = CALL_DECLARATOR_PARMS (decl);
9737
9738                 if (attrlist)
9739                   {
9740                     attributes = TREE_PURPOSE (attrlist);
9741                     prefix_attributes = TREE_VALUE (attrlist);
9742                   }
9743                 else
9744                   {
9745                     attributes = NULL_TREE;
9746                     prefix_attributes = NULL_TREE;
9747                   }
9748
9749                 decl = start_decl (declarator, declspecs, 1,
9750                                    attributes, prefix_attributes);
9751                 decl_type_access_control (decl);
9752                 if (decl)
9753                   {
9754                     /* Look for __unused__ attribute */
9755                     if (TREE_USED (TREE_TYPE (decl)))
9756                       TREE_USED (decl) = 1;
9757                     finish_decl (decl, init, NULL_TREE);
9758                   }
9759                 else
9760                   cp_error ("invalid declarator");
9761                 return 0;
9762               }
9763             innermost_code = TREE_CODE (decl);
9764             if (decl_context == FIELD && ctype == NULL_TREE)
9765               ctype = current_class_type;
9766             if (ctype
9767                 && TREE_OPERAND (decl, 0)
9768                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9769                     && ((DECL_NAME (TREE_OPERAND (decl, 0))
9770                          == constructor_name_full (ctype))
9771                         || (DECL_NAME (TREE_OPERAND (decl, 0))
9772                             == constructor_name (ctype)))))
9773               TREE_OPERAND (decl, 0) = constructor_name (ctype);
9774             next = &TREE_OPERAND (decl, 0);
9775             decl = *next;
9776             if (ctype != NULL_TREE
9777                 && decl != NULL_TREE && flags != DTOR_FLAG
9778                 && decl == constructor_name (ctype))
9779               {
9780                 sfk = sfk_constructor;
9781                 ctor_return_type = ctype;
9782               }
9783             ctype = NULL_TREE;
9784             break;
9785
9786           case TEMPLATE_ID_EXPR:
9787               {
9788                 tree fns = TREE_OPERAND (decl, 0);
9789
9790                 if (TREE_CODE (fns) == LOOKUP_EXPR)
9791                   fns = TREE_OPERAND (fns, 0);
9792
9793                 dname = fns;
9794                 if (TREE_CODE (dname) == COMPONENT_REF)
9795                   dname = TREE_OPERAND (dname, 1);
9796                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9797                   {
9798                     my_friendly_assert (is_overloaded_fn (dname),
9799                                         19990331);
9800                     dname = DECL_NAME (get_first_fn (dname));
9801                   }
9802               }
9803           /* Fall through. */
9804
9805           case IDENTIFIER_NODE:
9806             if (TREE_CODE (decl) == IDENTIFIER_NODE)
9807               dname = decl;
9808
9809             next = 0;
9810
9811             if (is_rid (dname))
9812               {
9813                 cp_error ("declarator-id missing; using reserved word `%D'",
9814                           dname);
9815                 name = IDENTIFIER_POINTER (dname);
9816               }
9817             else if (!IDENTIFIER_TYPENAME_P (dname))
9818               name = IDENTIFIER_POINTER (dname);
9819             else
9820               {
9821                 my_friendly_assert (flags == NO_SPECIAL, 154);
9822                 flags = TYPENAME_FLAG;
9823                 ctor_return_type = TREE_TYPE (dname);
9824                 sfk = sfk_conversion;
9825                 if (IDENTIFIER_GLOBAL_VALUE (dname)
9826                     && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (dname))
9827                         == TYPE_DECL))
9828                   name = IDENTIFIER_POINTER (dname);
9829                 else
9830                   name = "<invalid operator>";
9831               }
9832             break;
9833
9834             /* C++ extension */
9835           case SCOPE_REF:
9836             {
9837               /* Perform error checking, and decide on a ctype.  */
9838               tree cname = TREE_OPERAND (decl, 0);
9839               if (cname == NULL_TREE)
9840                 ctype = NULL_TREE;
9841               else if (TREE_CODE (cname) == NAMESPACE_DECL)
9842                 {
9843                   ctype = NULL_TREE;
9844                   in_namespace = TREE_OPERAND (decl, 0);
9845                   TREE_OPERAND (decl, 0) = NULL_TREE;
9846                 }
9847               else if (! is_aggr_type (cname, 1))
9848                 TREE_OPERAND (decl, 0) = NULL_TREE;
9849               /* Must test TREE_OPERAND (decl, 1), in case user gives
9850                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
9851               else if (TREE_OPERAND (decl, 1)
9852                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9853                 ctype = cname;
9854               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9855                        || TREE_CODE (cname) == TEMPLATE_TEMPLATE_PARM)
9856                 {
9857                   cp_error ("`%T::%D' is not a valid declarator", cname,
9858                             TREE_OPERAND (decl, 1));
9859                   cp_error ("  perhaps you want `typename %T::%D' to make it a type",
9860                             cname, TREE_OPERAND (decl, 1));
9861                   return void_type_node;
9862                 }
9863               else if (ctype == NULL_TREE)
9864                 ctype = cname;
9865               else if (TREE_COMPLEXITY (decl) == current_class_depth)
9866                 TREE_OPERAND (decl, 0) = ctype;
9867               else
9868                 {
9869                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9870                     {
9871                       cp_error ("type `%T' is not derived from type `%T'",
9872                                 cname, ctype);
9873                       TREE_OPERAND (decl, 0) = NULL_TREE;
9874                     }
9875                   else
9876                     ctype = cname;
9877                 }
9878
9879               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
9880                   && ((DECL_NAME (TREE_OPERAND (decl, 1))
9881                        == constructor_name_full (ctype))
9882                       || (DECL_NAME (TREE_OPERAND (decl, 1))
9883                           == constructor_name (ctype))))
9884                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
9885               next = &TREE_OPERAND (decl, 1);
9886               decl = *next;
9887               if (ctype)
9888                 {
9889                   if (TREE_CODE (decl) == IDENTIFIER_NODE
9890                       && constructor_name (ctype) == decl)
9891                     {
9892                       sfk = sfk_constructor;
9893                       ctor_return_type = ctype;
9894                     }
9895                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
9896                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
9897                            && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
9898                                || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
9899                     {
9900                       sfk = sfk_destructor;
9901                       ctor_return_type = ctype;
9902                       flags = DTOR_FLAG;
9903                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
9904                       next = &TREE_OPERAND (decl, 0);
9905                     }
9906                 }
9907             }
9908             break;
9909
9910           case ERROR_MARK:
9911             next = 0;
9912             break;
9913
9914           case TYPE_DECL:
9915             /* Parse error puts this typespec where
9916                a declarator should go.  */
9917             cp_error ("`%T' specified as declarator-id", DECL_NAME (decl));
9918             if (TREE_TYPE (decl) == current_class_type)
9919               cp_error ("  perhaps you want `%T' for a constructor",
9920                         current_class_name);
9921             dname = DECL_NAME (decl);
9922             name = IDENTIFIER_POINTER (dname);
9923
9924             /* Avoid giving two errors for this.  */
9925             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
9926
9927             declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
9928             *next = dname;
9929             next = 0;
9930             break;
9931
9932           default:
9933             cp_compiler_error ("`%D' as declarator", decl);
9934             return 0; /* We used to do a 155 abort here.  */
9935           }
9936       }
9937   }
9938
9939   /* A function definition's declarator must have the form of
9940      a function declarator.  */
9941
9942   if (funcdef_flag && innermost_code != CALL_EXPR)
9943     return 0;
9944
9945   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
9946       && innermost_code != CALL_EXPR
9947       && ! (ctype && declspecs == NULL_TREE))
9948     {
9949       cp_error ("declaration of `%D' as non-function", dname);
9950       return void_type_node;
9951     }
9952
9953   /* Anything declared one level down from the top level
9954      must be one of the parameters of a function
9955      (because the body is at least two levels down).  */
9956
9957   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9958      by not allowing C++ class definitions to specify their parameters
9959      with xdecls (must be spec.d in the parmlist).
9960
9961      Since we now wait to push a class scope until we are sure that
9962      we are in a legitimate method context, we must set oldcname
9963      explicitly (since current_class_name is not yet alive).
9964
9965      We also want to avoid calling this a PARM if it is in a namespace.  */
9966
9967   if (decl_context == NORMAL && !toplevel_bindings_p ())
9968     {
9969       struct binding_level *b = current_binding_level;
9970       current_binding_level = b->level_chain;
9971       if (current_binding_level != 0 && toplevel_bindings_p ())
9972         decl_context = PARM;
9973       current_binding_level = b;
9974     }
9975
9976   if (name == NULL)
9977     name = decl_context == PARM ? "parameter" : "type name";
9978
9979   /* Look through the decl specs and record which ones appear.
9980      Some typespecs are defined as built-in typenames.
9981      Others, the ones that are modifiers of other types,
9982      are represented by bits in SPECBITS: set the bits for
9983      the modifiers that appear.  Storage class keywords are also in SPECBITS.
9984
9985      If there is a typedef name or a type, store the type in TYPE.
9986      This includes builtin typedefs such as `int'.
9987
9988      Set EXPLICIT_INT if the type is `int' or `char' and did not
9989      come from a user typedef.
9990
9991      Set LONGLONG if `long' is mentioned twice.
9992
9993      For C++, constructors and destructors have their own fast treatment.  */
9994
9995   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
9996     {
9997       register int i;
9998       register tree id;
9999
10000       /* Certain parse errors slip through.  For example,
10001          `int class;' is not caught by the parser. Try
10002          weakly to recover here.  */
10003       if (TREE_CODE (spec) != TREE_LIST)
10004         return 0;
10005
10006       id = TREE_VALUE (spec);
10007
10008       if (TREE_CODE (id) == IDENTIFIER_NODE)
10009         {
10010           if (id == ridpointers[(int) RID_INT]
10011               || id == ridpointers[(int) RID_CHAR]
10012               || id == ridpointers[(int) RID_BOOL]
10013               || id == ridpointers[(int) RID_WCHAR])
10014             {
10015               if (type)
10016                 {
10017                   if (id == ridpointers[(int) RID_BOOL])
10018                     error ("`bool' is now a keyword");
10019                   else
10020                     cp_error ("extraneous `%T' ignored", id);
10021                 }
10022               else
10023                 {
10024                   if (id == ridpointers[(int) RID_INT])
10025                     explicit_int = 1;
10026                   else if (id == ridpointers[(int) RID_CHAR])
10027                     explicit_char = 1;
10028                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
10029                 }
10030               goto found;
10031             }
10032           /* C++ aggregate types.  */
10033           if (IDENTIFIER_HAS_TYPE_VALUE (id))
10034             {
10035               if (type)
10036                 cp_error ("multiple declarations `%T' and `%T'", type, id);
10037               else
10038                 type = IDENTIFIER_TYPE_VALUE (id);
10039               goto found;
10040             }
10041
10042           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
10043             {
10044               if (ridpointers[i] == id)
10045                 {
10046                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
10047                     {
10048                       if (pedantic && ! in_system_header && warn_long_long)
10049                         pedwarn ("ISO C++ does not support `long long'");
10050                       if (longlong)
10051                         error ("`long long long' is too long for GCC");
10052                       else
10053                         longlong = 1;
10054                     }
10055                   else if (RIDBIT_SETP (i, specbits))
10056                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
10057                   RIDBIT_SET (i, specbits);
10058                   goto found;
10059                 }
10060             }
10061         }
10062       /* C++ aggregate types.  */
10063       else if (TREE_CODE (id) == TYPE_DECL || TREE_CODE (id) == TEMPLATE_DECL)
10064         {
10065           if (type)
10066             cp_error ("multiple declarations `%T' and `%T'", type,
10067                       TREE_TYPE (id));
10068           else
10069             {
10070               type = TREE_TYPE (id);
10071               TREE_VALUE (spec) = type;
10072             }
10073           goto found;
10074         }
10075       if (type)
10076         error ("two or more data types in declaration of `%s'", name);
10077       else if (TREE_CODE (id) == IDENTIFIER_NODE)
10078         {
10079           register tree t = lookup_name (id, 1);
10080           if (!t || TREE_CODE (t) != TYPE_DECL)
10081             error ("`%s' fails to be a typedef or built in type",
10082                    IDENTIFIER_POINTER (id));
10083           else
10084             {
10085               type = TREE_TYPE (t);
10086 #if 0
10087               /* See the code below that used this.  */
10088               decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
10089 #endif
10090               typedef_decl = t;
10091             }
10092         }
10093       else if (id != error_mark_node)
10094         /* Can't change CLASS nodes into RECORD nodes here!  */
10095         type = id;
10096
10097     found: ;
10098     }
10099
10100   typedef_type = type;
10101
10102   /* No type at all: default to `int', and set DEFAULTED_INT
10103      because it was not a user-defined typedef.  */
10104
10105   if (type == NULL_TREE
10106       && (RIDBIT_SETP (RID_SIGNED, specbits)
10107           || RIDBIT_SETP (RID_UNSIGNED, specbits)
10108           || RIDBIT_SETP (RID_LONG, specbits)
10109           || RIDBIT_SETP (RID_SHORT, specbits)))
10110     {
10111       /* These imply 'int'.  */
10112       type = integer_type_node;
10113       defaulted_int = 1;
10114     }
10115
10116   if (sfk != sfk_none)
10117     type = check_special_function_return_type (sfk, type,
10118                                                ctor_return_type,
10119                                                ctor_return_type);
10120   else if (type == NULL_TREE)
10121     {
10122       int is_main;
10123
10124       explicit_int = -1;
10125
10126           /* We handle `main' specially here, because 'main () { }' is so
10127              common.  With no options, it is allowed.  With -Wreturn-type,
10128              it is a warning.  It is only an error with -pedantic-errors.  */
10129       is_main = (funcdef_flag
10130                  && MAIN_NAME_P (dname)
10131                  && ctype == NULL_TREE
10132                  && in_namespace == NULL_TREE
10133                  && current_namespace == global_namespace);
10134
10135       if (in_system_header || flag_ms_extensions)
10136         /* Allow it, sigh.  */;
10137       else if (pedantic || ! is_main)
10138         cp_pedwarn ("ISO C++ forbids declaration of `%s' with no type",
10139                     name);
10140       else if (warn_return_type)
10141         cp_warning ("ISO C++ forbids declaration of `%s' with no type",
10142                     name);
10143
10144       type = integer_type_node;
10145     }
10146
10147   ctype = NULL_TREE;
10148
10149   /* Now process the modifiers that were specified
10150      and check for invalid combinations.  */
10151
10152   /* Long double is a special combination.  */
10153
10154   if (RIDBIT_SETP (RID_LONG, specbits)
10155       && TYPE_MAIN_VARIANT (type) == double_type_node)
10156     {
10157       RIDBIT_RESET (RID_LONG, specbits);
10158       type = build_qualified_type (long_double_type_node,
10159                                    CP_TYPE_QUALS (type));
10160     }
10161
10162   /* Check all other uses of type modifiers.  */
10163
10164   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10165       || RIDBIT_SETP (RID_SIGNED, specbits)
10166       || RIDBIT_SETP (RID_LONG, specbits)
10167       || RIDBIT_SETP (RID_SHORT, specbits))
10168     {
10169       int ok = 0;
10170
10171       if (TREE_CODE (type) == REAL_TYPE)
10172         error ("short, signed or unsigned invalid for `%s'", name);
10173       else if (TREE_CODE (type) != INTEGER_TYPE)
10174         error ("long, short, signed or unsigned invalid for `%s'", name);
10175       else if (RIDBIT_SETP (RID_LONG, specbits)
10176                && RIDBIT_SETP (RID_SHORT, specbits))
10177         error ("long and short specified together for `%s'", name);
10178       else if ((RIDBIT_SETP (RID_LONG, specbits)
10179                 || RIDBIT_SETP (RID_SHORT, specbits))
10180                && explicit_char)
10181         error ("long or short specified with char for `%s'", name);
10182       else if ((RIDBIT_SETP (RID_LONG, specbits)
10183                 || RIDBIT_SETP (RID_SHORT, specbits))
10184                && TREE_CODE (type) == REAL_TYPE)
10185         error ("long or short specified with floating type for `%s'", name);
10186       else if (RIDBIT_SETP (RID_SIGNED, specbits)
10187                && RIDBIT_SETP (RID_UNSIGNED, specbits))
10188         error ("signed and unsigned given together for `%s'", name);
10189       else
10190         {
10191           ok = 1;
10192           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
10193             {
10194               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10195                        name);
10196               if (flag_pedantic_errors)
10197                 ok = 0;
10198             }
10199         }
10200
10201       /* Discard the type modifiers if they are invalid.  */
10202       if (! ok)
10203         {
10204           RIDBIT_RESET (RID_UNSIGNED, specbits);
10205           RIDBIT_RESET (RID_SIGNED, specbits);
10206           RIDBIT_RESET (RID_LONG, specbits);
10207           RIDBIT_RESET (RID_SHORT, specbits);
10208           longlong = 0;
10209         }
10210     }
10211
10212   if (RIDBIT_SETP (RID_COMPLEX, specbits)
10213       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
10214     {
10215       error ("complex invalid for `%s'", name);
10216       RIDBIT_RESET (RID_COMPLEX, specbits);
10217     }
10218
10219   /* Decide whether an integer type is signed or not.
10220      Optionally treat bitfields as signed by default.  */
10221   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10222       /* [class.bit]
10223
10224          It is implementation-defined whether a plain (neither
10225          explicitly signed or unsigned) char, short, int, or long
10226          bit-field is signed or unsigned.
10227
10228          Naturally, we extend this to long long as well.  Note that
10229          this does not include wchar_t.  */
10230       || (bitfield && !flag_signed_bitfields
10231           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
10232           /* A typedef for plain `int' without `signed' can be
10233              controlled just like plain `int', but a typedef for
10234              `signed int' cannot be so controlled.  */
10235           && !(typedef_decl
10236                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
10237           && (TREE_CODE (type) == INTEGER_TYPE
10238               || TREE_CODE (type) == CHAR_TYPE)
10239           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
10240     {
10241       if (longlong)
10242         type = long_long_unsigned_type_node;
10243       else if (RIDBIT_SETP (RID_LONG, specbits))
10244         type = long_unsigned_type_node;
10245       else if (RIDBIT_SETP (RID_SHORT, specbits))
10246         type = short_unsigned_type_node;
10247       else if (type == char_type_node)
10248         type = unsigned_char_type_node;
10249       else if (typedef_decl)
10250         type = unsigned_type (type);
10251       else
10252         type = unsigned_type_node;
10253     }
10254   else if (RIDBIT_SETP (RID_SIGNED, specbits)
10255            && type == char_type_node)
10256     type = signed_char_type_node;
10257   else if (longlong)
10258     type = long_long_integer_type_node;
10259   else if (RIDBIT_SETP (RID_LONG, specbits))
10260     type = long_integer_type_node;
10261   else if (RIDBIT_SETP (RID_SHORT, specbits))
10262     type = short_integer_type_node;
10263
10264   if (RIDBIT_SETP (RID_COMPLEX, specbits))
10265     {
10266       /* If we just have "complex", it is equivalent to
10267          "complex double", but if any modifiers at all are specified it is
10268          the complex form of TYPE.  E.g, "complex short" is
10269          "complex short int".  */
10270
10271       if (defaulted_int && ! longlong
10272           && ! (RIDBIT_SETP (RID_LONG, specbits)
10273                 || RIDBIT_SETP (RID_SHORT, specbits)
10274                 || RIDBIT_SETP (RID_SIGNED, specbits)
10275                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
10276         type = complex_double_type_node;
10277       else if (type == integer_type_node)
10278         type = complex_integer_type_node;
10279       else if (type == float_type_node)
10280         type = complex_float_type_node;
10281       else if (type == double_type_node)
10282         type = complex_double_type_node;
10283       else if (type == long_double_type_node)
10284         type = complex_long_double_type_node;
10285       else
10286         type = build_complex_type (type);
10287     }
10288
10289   if (sfk == sfk_conversion
10290       && (RIDBIT_SETP (RID_CONST, specbits)
10291           || RIDBIT_SETP (RID_VOLATILE, specbits)
10292           || RIDBIT_SETP (RID_RESTRICT, specbits)))
10293     cp_error ("qualifiers are not allowed on declaration of `operator %T'",
10294               ctor_return_type);
10295
10296   /* Set CONSTP if this declaration is `const', whether by
10297      explicit specification or via a typedef.
10298      Likewise for VOLATILEP.  */
10299
10300   constp = !! RIDBIT_SETP (RID_CONST, specbits) + CP_TYPE_CONST_P (type);
10301   restrictp =
10302     !! RIDBIT_SETP (RID_RESTRICT, specbits) + CP_TYPE_RESTRICT_P (type);
10303   volatilep =
10304     !! RIDBIT_SETP (RID_VOLATILE, specbits) + CP_TYPE_VOLATILE_P (type);
10305   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10306                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10307                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10308   type = cp_build_qualified_type (type, type_quals);
10309   staticp = 0;
10310   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
10311   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
10312   RIDBIT_RESET (RID_VIRTUAL, specbits);
10313   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
10314   RIDBIT_RESET (RID_EXPLICIT, specbits);
10315
10316   if (RIDBIT_SETP (RID_STATIC, specbits))
10317     staticp = 1 + (decl_context == FIELD);
10318
10319   if (virtualp && staticp == 2)
10320     {
10321       cp_error ("member `%D' cannot be declared both virtual and static",
10322                 dname);
10323       staticp = 0;
10324     }
10325   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
10326   RIDBIT_RESET (RID_FRIEND, specbits);
10327
10328   /* Warn if two storage classes are given. Default to `auto'.  */
10329
10330   if (RIDBIT_ANY_SET (specbits))
10331     {
10332       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
10333       if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
10334       if (decl_context == PARM && nclasses > 0)
10335         error ("storage class specifiers invalid in parameter declarations");
10336       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10337         {
10338           if (decl_context == PARM)
10339             error ("typedef declaration invalid in parameter declaration");
10340           nclasses++;
10341         }
10342       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
10343       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
10344     }
10345
10346   /* Give error if `virtual' is used outside of class declaration.  */
10347   if (virtualp
10348       && (current_class_name == NULL_TREE || decl_context != FIELD))
10349     {
10350       error ("virtual outside class declaration");
10351       virtualp = 0;
10352     }
10353
10354   /* Static anonymous unions are dealt with here.  */
10355   if (staticp && decl_context == TYPENAME
10356       && TREE_CODE (declspecs) == TREE_LIST
10357       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
10358     decl_context = FIELD;
10359
10360   /* Warn about storage classes that are invalid for certain
10361      kinds of declarations (parameters, typenames, etc.).  */
10362
10363   if (nclasses > 1)
10364     error ("multiple storage classes in declaration of `%s'", name);
10365   else if (decl_context != NORMAL && nclasses > 0)
10366     {
10367       if ((decl_context == PARM || decl_context == CATCHPARM)
10368           && (RIDBIT_SETP (RID_REGISTER, specbits)
10369               || RIDBIT_SETP (RID_AUTO, specbits)))
10370         ;
10371       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10372         ;
10373       else if (decl_context == FIELD
10374                /* C++ allows static class elements  */
10375                && RIDBIT_SETP (RID_STATIC, specbits))
10376         /* C++ also allows inlines and signed and unsigned elements,
10377            but in those cases we don't come in here.  */
10378         ;
10379       else
10380         {
10381           if (decl_context == FIELD)
10382             {
10383               tree tmp = NULL_TREE;
10384               register int op = 0;
10385
10386               if (declarator)
10387                 {
10388                   /* Avoid trying to get an operand off an identifier node.  */
10389                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10390                     tmp = declarator;
10391                   else
10392                     tmp = TREE_OPERAND (declarator, 0);
10393                   op = IDENTIFIER_OPNAME_P (tmp);
10394                   if (IDENTIFIER_TYPENAME_P (tmp))
10395                     {
10396                       if (IDENTIFIER_GLOBAL_VALUE (tmp)
10397                           && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (tmp))
10398                               == TYPE_DECL))
10399                         name = IDENTIFIER_POINTER (tmp);
10400                       else
10401                         name = "<invalid operator>";
10402                     }
10403                 }
10404               error ("storage class specified for %s `%s'",
10405                      op ? "member operator" : "field",
10406                      name);
10407             }
10408           else
10409             {
10410               if (decl_context == PARM || decl_context == CATCHPARM)
10411                 error ("storage class specified for parameter `%s'", name);
10412               else
10413                 error ("storage class specified for typename");
10414             }
10415           RIDBIT_RESET (RID_REGISTER, specbits);
10416           RIDBIT_RESET (RID_AUTO, specbits);
10417           RIDBIT_RESET (RID_EXTERN, specbits);
10418         }
10419     }
10420   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10421     {
10422       if (toplevel_bindings_p ())
10423         {
10424           /* It's common practice (and completely valid) to have a const
10425              be initialized and declared extern.  */
10426           if (!(type_quals & TYPE_QUAL_CONST))
10427             warning ("`%s' initialized and declared `extern'", name);
10428         }
10429       else
10430         error ("`%s' has both `extern' and initializer", name);
10431     }
10432   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10433            && ! toplevel_bindings_p ())
10434     error ("nested function `%s' declared `extern'", name);
10435   else if (toplevel_bindings_p ())
10436     {
10437       if (RIDBIT_SETP (RID_AUTO, specbits))
10438         error ("top-level declaration of `%s' specifies `auto'", name);
10439     }
10440
10441   if (nclasses > 0 && friendp)
10442     error ("storage class specifiers invalid in friend function declarations");
10443
10444   /* Now figure out the structure of the declarator proper.
10445      Descend through it, creating more complex types, until we reach
10446      the declared identifier (or NULL_TREE, in an absolute declarator).  */
10447
10448   inner_attrs = NULL_TREE;
10449   ignore_attrs = 0;
10450
10451   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10452          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10453     {
10454       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10455          an INDIRECT_REF (for *...),
10456          a CALL_EXPR (for ...(...)),
10457          an identifier (for the name being declared)
10458          or a null pointer (for the place in an absolute declarator
10459          where the name was omitted).
10460          For the last two cases, we have just exited the loop.
10461
10462          For C++ it could also be
10463          a SCOPE_REF (for class :: ...).  In this case, we have converted
10464          sensible names to types, and those are the values we use to
10465          qualify the member name.
10466          an ADDR_EXPR (for &...),
10467          a BIT_NOT_EXPR (for destructors)
10468
10469          At this point, TYPE is the type of elements of an array,
10470          or for a function to return, or for a pointer to point to.
10471          After this sequence of ifs, TYPE is the type of the
10472          array or function or pointer, and DECLARATOR has had its
10473          outermost layer removed.  */
10474
10475       if (type == error_mark_node)
10476         {
10477           if (TREE_CODE (declarator) == SCOPE_REF)
10478             declarator = TREE_OPERAND (declarator, 1);
10479           else
10480             declarator = TREE_OPERAND (declarator, 0);
10481           continue;
10482         }
10483       if (quals != NULL_TREE
10484           && (declarator == NULL_TREE
10485               || TREE_CODE (declarator) != SCOPE_REF))
10486         {
10487           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10488             ctype = TYPE_METHOD_BASETYPE (type);
10489           if (ctype != NULL_TREE)
10490             {
10491               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10492               grok_method_quals (ctype, dummy, quals);
10493               type = TREE_TYPE (dummy);
10494               ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
10495               quals = NULL_TREE;
10496             }
10497         }
10498
10499       /* See the comment for the TREE_LIST case, below.  */
10500       if (ignore_attrs)
10501         ignore_attrs = 0;
10502       else if (inner_attrs)
10503         {
10504           decl_attributes (type, inner_attrs, NULL_TREE);
10505           inner_attrs = NULL_TREE;
10506         }
10507
10508       switch (TREE_CODE (declarator))
10509         {
10510         case TREE_LIST:
10511           {
10512             /* We encode a declarator with embedded attributes using
10513                a TREE_LIST.  The attributes apply to the declarator
10514                directly inside them, so we have to skip an iteration
10515                before applying them to the type.  If the declarator just
10516                inside is the declarator-id, we apply the attrs to the
10517                decl itself.  */
10518             inner_attrs = TREE_PURPOSE (declarator);
10519             ignore_attrs = 1;
10520             declarator = TREE_VALUE (declarator);
10521           }
10522           break;
10523
10524         case ARRAY_REF:
10525           {
10526             register tree size;
10527
10528             size = TREE_OPERAND (declarator, 1);
10529
10530             /* VC++ spells a zero-sized array with [].  */
10531             if (size == NULL_TREE && decl_context == FIELD && ! staticp
10532                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10533               size = integer_zero_node;
10534
10535             declarator = TREE_OPERAND (declarator, 0);
10536
10537             type = create_array_type_for_decl (dname, type, size);
10538
10539             /* VLAs never work as fields. */
10540             if (decl_context == FIELD && !processing_template_decl
10541                 && TREE_CODE (type) == ARRAY_TYPE
10542                 && TYPE_DOMAIN (type) != NULL_TREE
10543                 && !TREE_CONSTANT (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
10544               {
10545                 cp_error ("size of member `%D' is not constant", dname);
10546                 /* Proceed with arbitrary constant size, so that offset
10547                    computations don't get confused. */
10548                 type = create_array_type_for_decl (dname, TREE_TYPE (type),
10549                                                    integer_one_node);
10550               }
10551
10552             ctype = NULL_TREE;
10553           }
10554           break;
10555
10556         case CALL_EXPR:
10557           {
10558             tree arg_types;
10559             int funcdecl_p;
10560             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10561             tree inner_decl = TREE_OPERAND (declarator, 0);
10562
10563             /* Declaring a function type.
10564                Make sure we have a valid type for the function to return.  */
10565
10566             /* We now know that the TYPE_QUALS don't apply to the
10567                decl, but to its return type.  */
10568             type_quals = TYPE_UNQUALIFIED;
10569
10570             /* Warn about some types functions can't return.  */
10571
10572             if (TREE_CODE (type) == FUNCTION_TYPE)
10573               {
10574                 error ("`%s' declared as function returning a function", name);
10575                 type = integer_type_node;
10576               }
10577             if (TREE_CODE (type) == ARRAY_TYPE)
10578               {
10579                 error ("`%s' declared as function returning an array", name);
10580                 type = integer_type_node;
10581               }
10582
10583             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10584               inner_decl = TREE_OPERAND (inner_decl, 1);
10585
10586             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10587               inner_decl = dname;
10588
10589             /* Pick up type qualifiers which should be applied to `this'.  */
10590             quals = CALL_DECLARATOR_QUALS (declarator);
10591
10592             /* Pick up the exception specifications.  */
10593             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10594
10595             /* Say it's a definition only for the CALL_EXPR
10596                closest to the identifier.  */
10597             funcdecl_p
10598               = inner_decl
10599               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10600                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10601                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10602
10603             if (ctype == NULL_TREE
10604                 && decl_context == FIELD
10605                 && funcdecl_p
10606                 && (friendp == 0 || dname == current_class_name))
10607               ctype = current_class_type;
10608
10609             if (ctype && sfk == sfk_conversion)
10610               TYPE_HAS_CONVERSION (ctype) = 1;
10611             if (ctype && constructor_name (ctype) == dname)
10612               {
10613                 /* We are within a class's scope. If our declarator name
10614                    is the same as the class name, and we are defining
10615                    a function, then it is a constructor/destructor, and
10616                    therefore returns a void type.  */
10617
10618                 if (flags == DTOR_FLAG)
10619                   {
10620                     /* ISO C++ 12.4/2.  A destructor may not be
10621                        declared const or volatile.  A destructor may
10622                        not be static.  */
10623                     if (staticp == 2)
10624                       error ("destructor cannot be static member function");
10625                     if (quals)
10626                       {
10627                         cp_error ("destructors may not be `%s'",
10628                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10629                         quals = NULL_TREE;
10630                       }
10631                     if (decl_context == FIELD)
10632                       {
10633                         if (! member_function_or_else (ctype,
10634                                                        current_class_type,
10635                                                        flags))
10636                           return void_type_node;
10637                       }
10638                   }
10639                 else            /* It's a constructor.  */
10640                   {
10641                     if (explicitp == 1)
10642                       explicitp = 2;
10643                     /* ISO C++ 12.1.  A constructor may not be
10644                        declared const or volatile.  A constructor may
10645                        not be virtual.  A constructor may not be
10646                        static.  */
10647                     if (staticp == 2)
10648                       error ("constructor cannot be static member function");
10649                     if (virtualp)
10650                       {
10651                         pedwarn ("constructors cannot be declared virtual");
10652                         virtualp = 0;
10653                       }
10654                     if (quals)
10655                       {
10656                         cp_error ("constructors may not be `%s'",
10657                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10658                         quals = NULL_TREE;
10659                       }
10660                     {
10661                       RID_BIT_TYPE tmp_bits;
10662                       bcopy ((void*)&specbits, (void*)&tmp_bits, sizeof (RID_BIT_TYPE));
10663                       RIDBIT_RESET (RID_INLINE, tmp_bits);
10664                       RIDBIT_RESET (RID_STATIC, tmp_bits);
10665                       if (RIDBIT_ANY_SET (tmp_bits))
10666                         error ("return value type specifier for constructor ignored");
10667                     }
10668                     if (decl_context == FIELD)
10669                       {
10670                         if (! member_function_or_else (ctype,
10671                                                        current_class_type,
10672                                                        flags))
10673                           return void_type_node;
10674                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10675                         if (sfk != sfk_constructor)
10676                           return NULL_TREE;
10677                       }
10678                   }
10679                 if (decl_context == FIELD)
10680                   staticp = 0;
10681               }
10682             else if (friendp)
10683               {
10684                 if (initialized)
10685                   error ("can't initialize friend function `%s'", name);
10686                 if (virtualp)
10687                   {
10688                     /* Cannot be both friend and virtual.  */
10689                     error ("virtual functions cannot be friends");
10690                     RIDBIT_RESET (RID_FRIEND, specbits);
10691                     friendp = 0;
10692                   }
10693                 if (decl_context == NORMAL)
10694                   error ("friend declaration not in class definition");
10695                 if (current_function_decl && funcdef_flag)
10696                   cp_error ("can't define friend function `%s' in a local class definition",
10697                             name);
10698               }
10699
10700             /* Construct the function type and go to the next
10701                inner layer of declarator.  */
10702
10703             declarator = TREE_OPERAND (declarator, 0);
10704
10705             /* FIXME: This is where default args should be fully
10706                processed.  */
10707
10708             arg_types = grokparms (inner_parms, funcdecl_p ? funcdef_flag : 0);
10709
10710             if (declarator && flags == DTOR_FLAG)
10711               {
10712                 /* A destructor declared in the body of a class will
10713                    be represented as a BIT_NOT_EXPR.  But, we just
10714                    want the underlying IDENTIFIER.  */
10715                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10716                   declarator = TREE_OPERAND (declarator, 0);
10717
10718                 if (strict_prototype == 0 && arg_types == NULL_TREE)
10719                   arg_types = void_list_node;
10720                 else if (arg_types == NULL_TREE
10721                          || arg_types != void_list_node)
10722                   {
10723                     cp_error ("destructors may not have parameters");
10724                     arg_types = void_list_node;
10725                     last_function_parms = NULL_TREE;
10726                   }
10727               }
10728
10729             /* ANSI says that `const int foo ();'
10730                does not make the function foo const.  */
10731             type = build_function_type (type, arg_types);
10732
10733             {
10734               tree t;
10735               for (t = arg_types; t; t = TREE_CHAIN (t))
10736                 if (TREE_PURPOSE (t)
10737                     && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10738                   {
10739                     add_defarg_fn (type);
10740                     break;
10741                   }
10742             }
10743           }
10744           break;
10745
10746         case ADDR_EXPR:
10747         case INDIRECT_REF:
10748           /* Filter out pointers-to-references and references-to-references.
10749              We can get these if a TYPE_DECL is used.  */
10750
10751           if (TREE_CODE (type) == REFERENCE_TYPE)
10752             {
10753               error ("cannot declare %s to references",
10754                      TREE_CODE (declarator) == ADDR_EXPR
10755                      ? "references" : "pointers");
10756               declarator = TREE_OPERAND (declarator, 0);
10757               continue;
10758             }
10759
10760           if (TREE_CODE (type) == OFFSET_TYPE
10761               && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10762                   || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10763             {
10764               cp_error ("cannot declare pointer to `%#T' member",
10765                         TREE_TYPE (type));
10766               type = TREE_TYPE (type);
10767             }
10768
10769           /* Merge any constancy or volatility into the target type
10770              for the pointer.  */
10771
10772           /* We now know that the TYPE_QUALS don't apply to the decl,
10773              but to the target of the pointer.  */
10774           type_quals = TYPE_UNQUALIFIED;
10775
10776           if (TREE_CODE (declarator) == ADDR_EXPR)
10777             {
10778               if (TREE_CODE (type) == VOID_TYPE)
10779                 error ("invalid type: `void &'");
10780               else
10781                 type = build_reference_type (type);
10782             }
10783           else if (TREE_CODE (type) == METHOD_TYPE)
10784             type = build_ptrmemfunc_type (build_pointer_type (type));
10785           else
10786             type = build_pointer_type (type);
10787
10788           /* Process a list of type modifier keywords (such as
10789              const or volatile) that were given inside the `*' or `&'.  */
10790
10791           if (TREE_TYPE (declarator))
10792             {
10793               register tree typemodlist;
10794               int erred = 0;
10795
10796               constp = 0;
10797               volatilep = 0;
10798               restrictp = 0;
10799               for (typemodlist = TREE_TYPE (declarator); typemodlist;
10800                    typemodlist = TREE_CHAIN (typemodlist))
10801                 {
10802                   tree qualifier = TREE_VALUE (typemodlist);
10803
10804                   if (qualifier == ridpointers[(int) RID_CONST])
10805                     constp++;
10806                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
10807                     volatilep++;
10808                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
10809                     restrictp++;
10810                   else if (!erred)
10811                     {
10812                       erred = 1;
10813                       error ("invalid type modifier within pointer declarator");
10814                     }
10815                 }
10816               if (constp > 1)
10817                 pedwarn ("duplicate `const'");
10818               if (volatilep > 1)
10819                 pedwarn ("duplicate `volatile'");
10820               if (restrictp > 1)
10821                 pedwarn ("duplicate `restrict'");
10822
10823               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10824                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10825                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10826               if (TREE_CODE (declarator) == ADDR_EXPR
10827                   && (constp || volatilep))
10828                 {
10829                   if (constp)
10830                     pedwarn ("discarding `const' applied to a reference");
10831                   if (volatilep)
10832                     pedwarn ("discarding `volatile' applied to a reference");
10833                   type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
10834                 }
10835               type = cp_build_qualified_type (type, type_quals);
10836             }
10837           declarator = TREE_OPERAND (declarator, 0);
10838           ctype = NULL_TREE;
10839           break;
10840
10841         case SCOPE_REF:
10842           {
10843             /* We have converted type names to NULL_TREE if the
10844                name was bogus, or to a _TYPE node, if not.
10845
10846                The variable CTYPE holds the type we will ultimately
10847                resolve to.  The code here just needs to build
10848                up appropriate member types.  */
10849             tree sname = TREE_OPERAND (declarator, 1);
10850             tree t;
10851
10852             /* Destructors can have their visibilities changed as well.  */
10853             if (TREE_CODE (sname) == BIT_NOT_EXPR)
10854               sname = TREE_OPERAND (sname, 0);
10855
10856             if (TREE_COMPLEXITY (declarator) == 0)
10857               /* This needs to be here, in case we are called
10858                  multiple times.  */ ;
10859             else if (TREE_COMPLEXITY (declarator) == -1)
10860               /* Namespace member. */
10861               pop_decl_namespace ();
10862             else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
10863               /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10864             else if (! IS_AGGR_TYPE_CODE
10865                      (TREE_CODE (TREE_OPERAND (declarator, 0))))
10866               ;
10867             else if (TREE_COMPLEXITY (declarator) == current_class_depth)
10868               {
10869                 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10870                    that refer to ctype.  They couldn't be resolved earlier
10871                    because we hadn't pushed into the class yet.
10872                    Example: resolve 'B<T>::type' in
10873                    'B<typename B<T>::type> B<T>::f () { }'.  */
10874                 if (current_template_parms
10875                     && uses_template_parms (type)
10876                     && uses_template_parms (current_class_type))
10877                   {
10878                     tree args = current_template_args ();
10879                     type = tsubst (type, args, /*complain=*/1, NULL_TREE);
10880                   }
10881
10882                 /* This pop_nested_class corresponds to the
10883                    push_nested_class used to push into class scope for
10884                    parsing the argument list of a function decl, in
10885                    qualified_id.  */
10886                 pop_nested_class ();
10887                 TREE_COMPLEXITY (declarator) = current_class_depth;
10888               }
10889             else
10890               my_friendly_abort (16);
10891
10892             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
10893               {
10894                 /* We had a reference to a global decl, or
10895                    perhaps we were given a non-aggregate typedef,
10896                    in which case we cleared this out, and should just
10897                    keep going as though it wasn't there.  */
10898                 declarator = sname;
10899                 continue;
10900               }
10901             ctype = TREE_OPERAND (declarator, 0);
10902
10903             t = ctype;
10904             while (t != NULL_TREE && CLASS_TYPE_P (t))
10905               {
10906                 /* You're supposed to have one `template <...>'
10907                    for every template class, but you don't need one
10908                    for a full specialization.  For example:
10909
10910                      template <class T> struct S{};
10911                      template <> struct S<int> { void f(); };
10912                      void S<int>::f () {}
10913
10914                    is correct; there shouldn't be a `template <>' for
10915                    the definition of `S<int>::f'.  */
10916                 if (CLASSTYPE_TEMPLATE_INFO (t)
10917                     && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
10918                         || uses_template_parms (CLASSTYPE_TI_ARGS (t))))
10919                   template_count += 1;
10920
10921                 t = TYPE_MAIN_DECL (t);
10922                 if (DECL_LANG_SPECIFIC (t))
10923                   t = DECL_CONTEXT (t);
10924                 else
10925                   t = NULL_TREE;
10926               }
10927
10928             if (sname == NULL_TREE)
10929               goto done_scoping;
10930
10931             if (TREE_CODE (sname) == IDENTIFIER_NODE)
10932               {
10933                 /* This is the `standard' use of the scoping operator:
10934                    basetype :: member .  */
10935
10936                 if (ctype == current_class_type)
10937                   {
10938                     /* class A {
10939                          void A::f ();
10940                        };
10941
10942                        Is this ill-formed?  */
10943
10944                     if (pedantic)
10945                       cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10946                                   ctype, name);
10947                   }
10948                 else if (TREE_CODE (type) == FUNCTION_TYPE)
10949                   {
10950                     if (current_class_type == NULL_TREE
10951                         || friendp)
10952                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10953                                                       TYPE_ARG_TYPES (type));
10954                     else
10955                       {
10956                         cp_error ("cannot declare member function `%T::%s' within `%T'",
10957                                   ctype, name, current_class_type);
10958                         return void_type_node;
10959                       }
10960                   }
10961                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
10962                          || COMPLETE_TYPE_P (complete_type (ctype)))
10963                   {
10964                     /* Have to move this code elsewhere in this function.
10965                        this code is used for i.e., typedef int A::M; M *pm;
10966
10967                        It is?  How? jason 10/2/94 */
10968
10969                     if (current_class_type)
10970                       {
10971                         cp_error ("cannot declare member `%T::%s' within `%T'",
10972                                   ctype, name, current_class_type);
10973                         return void_type_node;
10974                       }
10975                     type = build_offset_type (ctype, type);
10976                   }
10977                 else if (uses_template_parms (ctype))
10978                   {
10979                     if (TREE_CODE (type) == FUNCTION_TYPE)
10980                       type
10981                         = build_cplus_method_type (ctype, TREE_TYPE (type),
10982                                                    TYPE_ARG_TYPES (type));
10983                   }
10984                 else
10985                   {
10986                     cp_error ("structure `%T' not yet defined", ctype);
10987                     return error_mark_node;
10988                   }
10989
10990                 declarator = sname;
10991               }
10992             else if (TREE_CODE (sname) == SCOPE_REF)
10993               my_friendly_abort (17);
10994             else
10995               {
10996               done_scoping:
10997                 declarator = TREE_OPERAND (declarator, 1);
10998                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
10999                   /* In this case, we will deal with it later.  */
11000                   ;
11001                 else
11002                   {
11003                     if (TREE_CODE (type) == FUNCTION_TYPE)
11004                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
11005                                                       TYPE_ARG_TYPES (type));
11006                     else
11007                       type = build_offset_type (ctype, type);
11008                   }
11009               }
11010           }
11011           break;
11012
11013         case BIT_NOT_EXPR:
11014           declarator = TREE_OPERAND (declarator, 0);
11015           break;
11016
11017         case RECORD_TYPE:
11018         case UNION_TYPE:
11019         case ENUMERAL_TYPE:
11020           declarator = NULL_TREE;
11021           break;
11022
11023         case ERROR_MARK:
11024           declarator = NULL_TREE;
11025           break;
11026
11027         default:
11028           my_friendly_abort (158);
11029         }
11030     }
11031
11032   /* See the comment for the TREE_LIST case, above.  */
11033   if (inner_attrs)
11034     {
11035       if (! ignore_attrs)
11036         decl_attributes (type, inner_attrs, NULL_TREE);
11037       else if (attrlist)
11038         TREE_VALUE (attrlist) = chainon (inner_attrs, TREE_VALUE (attrlist));
11039       else
11040         attrlist = build_decl_list (NULL_TREE, inner_attrs);
11041     }
11042
11043   /* Now TYPE has the actual type.  */
11044
11045   if (explicitp == 1 || (explicitp && friendp))
11046     {
11047       /* [dcl.fct.spec] The explicit specifier shall only be used in
11048          declarations of constructors within a class definition.  */
11049       error ("only declarations of constructors can be `explicit'");
11050       explicitp = 0;
11051     }
11052
11053   if (RIDBIT_SETP (RID_MUTABLE, specbits))
11054     {
11055       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
11056         {
11057           error ("non-member `%s' cannot be declared `mutable'", name);
11058           RIDBIT_RESET (RID_MUTABLE, specbits);
11059         }
11060       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
11061         {
11062           error ("non-object member `%s' cannot be declared `mutable'", name);
11063           RIDBIT_RESET (RID_MUTABLE, specbits);
11064         }
11065       else if (TREE_CODE (type) == FUNCTION_TYPE
11066                || TREE_CODE (type) == METHOD_TYPE)
11067         {
11068           error ("function `%s' cannot be declared `mutable'", name);
11069           RIDBIT_RESET (RID_MUTABLE, specbits);
11070         }
11071       else if (staticp)
11072         {
11073           error ("static `%s' cannot be declared `mutable'", name);
11074           RIDBIT_RESET (RID_MUTABLE, specbits);
11075         }
11076       else if (type_quals & TYPE_QUAL_CONST)
11077         {
11078           error ("const `%s' cannot be declared `mutable'", name);
11079           RIDBIT_RESET (RID_MUTABLE, specbits);
11080         }
11081     }
11082
11083   if (declarator == NULL_TREE
11084       || TREE_CODE (declarator) == IDENTIFIER_NODE
11085       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
11086           && (TREE_CODE (type) == FUNCTION_TYPE
11087               || TREE_CODE (type) == METHOD_TYPE)))
11088     /* OK */;
11089   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11090     {
11091       cp_error ("template-id `%D' used as a declarator", declarator);
11092       declarator = dname;
11093     }
11094   else
11095     /* Unexpected declarator format.  */
11096     my_friendly_abort (990210);
11097
11098   /* If this is declaring a typedef name, return a TYPE_DECL.  */
11099
11100   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
11101     {
11102       tree decl;
11103
11104       /* Note that the grammar rejects storage classes
11105          in typenames, fields or parameters.  */
11106       if (current_lang_name == lang_name_java)
11107         TYPE_FOR_JAVA (type) = 1;
11108
11109       if (decl_context == FIELD)
11110         {
11111           if (declarator == constructor_name (current_class_type))
11112             cp_pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
11113                         declarator);
11114           decl = build_lang_decl (TYPE_DECL, declarator, type);
11115         }
11116       else
11117         decl = build_decl (TYPE_DECL, declarator, type);
11118
11119       /* If the user declares "typedef struct {...} foo" then the
11120          struct will have an anonymous name.  Fill that name in now.
11121          Nothing can refer to it, so nothing needs know about the name
11122          change.  */
11123       if (type != error_mark_node
11124           && declarator
11125           && TYPE_NAME (type)
11126           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11127           && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type))
11128           && CP_TYPE_QUALS (type) == TYPE_UNQUALIFIED)
11129         {
11130           tree oldname = TYPE_NAME (type);
11131           tree t;
11132
11133           /* Replace the anonymous name with the real name everywhere.  */
11134           lookup_tag_reverse (type, declarator);
11135           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
11136             if (TYPE_NAME (t) == oldname)
11137               TYPE_NAME (t) = decl;
11138
11139           if (TYPE_LANG_SPECIFIC (type))
11140             TYPE_WAS_ANONYMOUS (type) = 1;
11141
11142           /* If this is a typedef within a template class, the nested
11143              type is a (non-primary) template.  The name for the
11144              template needs updating as well.  */
11145           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
11146             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
11147               = TYPE_IDENTIFIER (type);
11148
11149           /* XXX Temporarily set the scope.
11150              When returning, start_decl expects it as NULL_TREE,
11151              and will then then set it using pushdecl. */
11152           my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 980404);
11153           if (current_class_type)
11154             DECL_CONTEXT (decl) = current_class_type;
11155           else
11156             DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
11157
11158           DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
11159           DECL_ASSEMBLER_NAME (decl)
11160             = get_identifier (build_overload_name (type, 1, 1));
11161           DECL_CONTEXT (decl) = NULL_TREE;
11162
11163           /* FIXME remangle member functions; member functions of a
11164              type with external linkage have external linkage.  */
11165         }
11166
11167       if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
11168         {
11169           cp_error_at ("typedef name may not be class-qualified", decl);
11170           return NULL_TREE;
11171         }
11172       else if (quals)
11173         {
11174           if (ctype == NULL_TREE)
11175             {
11176               if (TREE_CODE (type) != METHOD_TYPE)
11177                 cp_error_at ("invalid type qualifier for non-member function type", decl);
11178               else
11179                 ctype = TYPE_METHOD_BASETYPE (type);
11180             }
11181           if (ctype != NULL_TREE)
11182             grok_method_quals (ctype, decl, quals);
11183         }
11184
11185       if (RIDBIT_SETP (RID_SIGNED, specbits)
11186           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
11187         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
11188
11189       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
11190                       inlinep, friendp, raises != NULL_TREE);
11191
11192       if (initialized)
11193         error ("typedef declaration includes an initializer");
11194
11195       return decl;
11196     }
11197
11198   /* Detect the case of an array type of unspecified size
11199      which came, as such, direct from a typedef name.
11200      We must copy the type, so that each identifier gets
11201      a distinct type, so that each identifier's size can be
11202      controlled separately by its own initializer.  */
11203
11204   if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
11205       && TYPE_DOMAIN (type) == NULL_TREE)
11206     {
11207       type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
11208     }
11209
11210   /* If this is a type name (such as, in a cast or sizeof),
11211      compute the type and return it now.  */
11212
11213   if (decl_context == TYPENAME)
11214     {
11215       /* Note that the grammar rejects storage classes
11216          in typenames, fields or parameters.  */
11217       if (type_quals != TYPE_UNQUALIFIED)
11218         type_quals = TYPE_UNQUALIFIED;
11219
11220       /* Special case: "friend class foo" looks like a TYPENAME context.  */
11221       if (friendp)
11222         {
11223           if (type_quals != TYPE_UNQUALIFIED)
11224             {
11225               cp_error ("type qualifiers specified for friend class declaration");
11226               type_quals = TYPE_UNQUALIFIED;
11227             }
11228           if (inlinep)
11229             {
11230               cp_error ("`inline' specified for friend class declaration");
11231               inlinep = 0;
11232             }
11233
11234           /* Only try to do this stuff if we didn't already give up.  */
11235           if (type != integer_type_node)
11236             {
11237               /* A friendly class?  */
11238               if (current_class_type)
11239                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
11240               else
11241                 error ("trying to make class `%s' a friend of global scope",
11242                        TYPE_NAME_STRING (type));
11243               type = void_type_node;
11244             }
11245         }
11246       else if (quals)
11247         {
11248           if (ctype == NULL_TREE)
11249             {
11250               if (TREE_CODE (type) != METHOD_TYPE)
11251                 cp_error ("invalid qualifiers on non-member function type");
11252               else
11253                 ctype = TYPE_METHOD_BASETYPE (type);
11254             }
11255           if (ctype)
11256             {
11257               tree dummy = build_decl (TYPE_DECL, declarator, type);
11258               grok_method_quals (ctype, dummy, quals);
11259               type = TREE_TYPE (dummy);
11260             }
11261         }
11262
11263       return type;
11264     }
11265   else if (declarator == NULL_TREE && decl_context != PARM
11266            && decl_context != CATCHPARM
11267            && TREE_CODE (type) != UNION_TYPE
11268            && ! bitfield)
11269     {
11270       cp_error ("abstract declarator `%T' used as declaration", type);
11271       declarator = make_anon_name ();
11272     }
11273
11274   /* `void' at top level (not within pointer)
11275      is allowed only in typedefs or type names.
11276      We don't complain about parms either, but that is because
11277      a better error message can be made later.  */
11278
11279   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
11280     {
11281       if (! declarator)
11282         error ("unnamed variable or field declared void");
11283       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
11284         {
11285           if (IDENTIFIER_OPNAME_P (declarator))
11286             my_friendly_abort (356);
11287           else
11288             error ("variable or field `%s' declared void", name);
11289         }
11290       else
11291         error ("variable or field declared void");
11292       type = integer_type_node;
11293     }
11294
11295   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11296      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
11297
11298   if (decl_context == PARM || decl_context == CATCHPARM)
11299     {
11300       if (ctype || in_namespace)
11301         error ("cannot use `::' in parameter declaration");
11302
11303       /* A parameter declared as an array of T is really a pointer to T.
11304          One declared as a function is really a pointer to a function.
11305          One declared as a member is really a pointer to member.  */
11306
11307       if (TREE_CODE (type) == ARRAY_TYPE)
11308         {
11309           /* Transfer const-ness of array into that of type pointed to.  */
11310           type = build_pointer_type (TREE_TYPE (type));
11311           type_quals = TYPE_UNQUALIFIED;
11312         }
11313       else if (TREE_CODE (type) == FUNCTION_TYPE)
11314         type = build_pointer_type (type);
11315       else if (TREE_CODE (type) == OFFSET_TYPE)
11316         type = build_pointer_type (type);
11317       else if (TREE_CODE (type) == VOID_TYPE && declarator)
11318         {
11319           error ("declaration of `%s' as void", name);
11320           return NULL_TREE;
11321         }
11322     }
11323
11324   {
11325     register tree decl;
11326
11327     if (decl_context == PARM)
11328       {
11329         decl = build_decl (PARM_DECL, declarator, type);
11330
11331         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
11332                         inlinep, friendp, raises != NULL_TREE);
11333
11334         /* Compute the type actually passed in the parmlist,
11335            for the case where there is no prototype.
11336            (For example, shorts and chars are passed as ints.)
11337            When there is a prototype, this is overridden later.  */
11338
11339         DECL_ARG_TYPE (decl) = type_promotes_to (type);
11340       }
11341     else if (decl_context == FIELD)
11342       {
11343         if (type == error_mark_node)
11344           {
11345             /* Happens when declaring arrays of sizes which
11346                are error_mark_node, for example.  */
11347             decl = NULL_TREE;
11348           }
11349         else if (in_namespace && !friendp)
11350           {
11351             /* Something like struct S { int N::j; };  */
11352             cp_error ("invalid use of `::'");
11353             decl = NULL_TREE;
11354           }
11355         else if (TREE_CODE (type) == FUNCTION_TYPE)
11356           {
11357             int publicp = 0;
11358             tree function_context;
11359
11360             /* We catch the others as conflicts with the builtin
11361                typedefs.  */
11362             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11363               {
11364                 cp_error ("function `%D' cannot be declared friend",
11365                           declarator);
11366                 friendp = 0;
11367               }
11368
11369             if (friendp == 0)
11370               {
11371                 if (ctype == NULL_TREE)
11372                   ctype = current_class_type;
11373
11374                 if (ctype == NULL_TREE)
11375                   {
11376                     cp_error ("can't make `%D' into a method -- not in a class",
11377                               declarator);
11378                     return void_type_node;
11379                   }
11380
11381                 /* ``A union may [ ... ] not [ have ] virtual functions.''
11382                    ARM 9.5 */
11383                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11384                   {
11385                     cp_error ("function `%D' declared virtual inside a union",
11386                               declarator);
11387                     return void_type_node;
11388                   }
11389
11390                 if (declarator == ansi_opname (NEW_EXPR)
11391                     || declarator == ansi_opname (VEC_NEW_EXPR)
11392                     || declarator == ansi_opname (DELETE_EXPR)
11393                     || declarator == ansi_opname (VEC_DELETE_EXPR))
11394                   {
11395                     if (virtualp)
11396                       {
11397                         cp_error ("`%D' cannot be declared virtual, since it is always static",
11398                                   declarator);
11399                         virtualp = 0;
11400                       }
11401                   }
11402                 else if (staticp < 2)
11403                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11404                                                   TYPE_ARG_TYPES (type));
11405               }
11406
11407             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
11408             function_context = (ctype != NULL_TREE) ?
11409               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11410             publicp = (! friendp || ! staticp)
11411               && function_context == NULL_TREE;
11412             decl = grokfndecl (ctype, type,
11413                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11414                                ? declarator : dname,
11415                                declarator,
11416                                virtualp, flags, quals, raises,
11417                                friendp ? -1 : 0, friendp, publicp, inlinep,
11418                                funcdef_flag, template_count, in_namespace);
11419             if (decl == NULL_TREE)
11420               return decl;
11421 #if 0
11422             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
11423             /* The decl and setting of decl_machine_attr is also turned off.  */
11424             decl = build_decl_attribute_variant (decl, decl_machine_attr);
11425 #endif
11426
11427             /* [class.conv.ctor]
11428
11429                A constructor declared without the function-specifier
11430                explicit that can be called with a single parameter
11431                specifies a conversion from the type of its first
11432                parameter to the type of its class.  Such a constructor
11433                is called a converting constructor.  */
11434             if (explicitp == 2)
11435               DECL_NONCONVERTING_P (decl) = 1;
11436             else if (DECL_CONSTRUCTOR_P (decl))
11437               {
11438                 /* The constructor can be called with exactly one
11439                    parameter if there is at least one parameter, and
11440                    any subsequent parameters have default arguments.
11441                    We don't look at the first parameter, which is
11442                    really just the `this' parameter for the new
11443                    object.  */
11444                 tree arg_types =
11445                   TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)));
11446
11447                 /* Skip the `in_chrg' argument too, if present.  */
11448                 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
11449                   arg_types = TREE_CHAIN (arg_types);
11450
11451                 if (arg_types == void_list_node
11452                     || (arg_types
11453                         && TREE_CHAIN (arg_types)
11454                         && TREE_CHAIN (arg_types) != void_list_node
11455                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11456                   DECL_NONCONVERTING_P (decl) = 1;
11457               }
11458           }
11459         else if (TREE_CODE (type) == METHOD_TYPE)
11460           {
11461             /* We only get here for friend declarations of
11462                members of other classes.  */
11463             /* All method decls are public, so tell grokfndecl to set
11464                TREE_PUBLIC, also.  */
11465             decl = grokfndecl (ctype, type, declarator, declarator,
11466                                virtualp, flags, quals, raises,
11467                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11468                                template_count, in_namespace);
11469             if (decl == NULL_TREE)
11470               return NULL_TREE;
11471           }
11472         else if (!staticp && ! processing_template_decl
11473                  && !COMPLETE_TYPE_P (complete_type (type))
11474                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11475           {
11476             if (declarator)
11477               cp_error ("field `%D' has incomplete type", declarator);
11478             else
11479               cp_error ("name `%T' has incomplete type", type);
11480
11481             /* If we're instantiating a template, tell them which
11482                instantiation made the field's type be incomplete.  */
11483             if (current_class_type
11484                 && TYPE_NAME (current_class_type)
11485                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11486                 && declspecs && TREE_VALUE (declspecs)
11487                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11488               cp_error ("  in instantiation of template `%T'",
11489                         current_class_type);
11490
11491             type = error_mark_node;
11492             decl = NULL_TREE;
11493           }
11494         else
11495           {
11496             if (friendp)
11497               {
11498                 error ("`%s' is neither function nor member function; cannot be declared friend",
11499                        IDENTIFIER_POINTER (declarator));
11500                 friendp = 0;
11501               }
11502             decl = NULL_TREE;
11503           }
11504
11505         if (friendp)
11506           {
11507             /* Friends are treated specially.  */
11508             if (ctype == current_class_type)
11509               warning ("member functions are implicitly friends of their class");
11510             else
11511               {
11512                 tree t = NULL_TREE;
11513                 if (decl && DECL_NAME (decl))
11514                   {
11515                     if (template_class_depth (current_class_type) == 0)
11516                       {
11517                         decl
11518                           = check_explicit_specialization
11519                           (declarator, decl,
11520                            template_count, 2 * (funcdef_flag != 0) + 4);
11521                         if (decl == error_mark_node)
11522                           return error_mark_node;
11523                       }
11524
11525                     t = do_friend (ctype, declarator, decl,
11526                                    last_function_parms, attrlist, flags, quals,
11527                                    funcdef_flag);
11528                   }
11529                 if (t && funcdef_flag)
11530                   return t;
11531
11532                 return void_type_node;
11533               }
11534           }
11535
11536         /* Structure field.  It may not be a function, except for C++ */
11537
11538         if (decl == NULL_TREE)
11539           {
11540             if (initialized)
11541               {
11542                 if (!staticp)
11543                   {
11544                     /* An attempt is being made to initialize a non-static
11545                        member.  But, from [class.mem]:
11546
11547                        4 A member-declarator can contain a
11548                        constant-initializer only if it declares a static
11549                        member (_class.static_) of integral or enumeration
11550                        type, see _class.static.data_.
11551
11552                        This used to be relatively common practice, but
11553                        the rest of the compiler does not correctly
11554                        handle the initialization unless the member is
11555                        static so we make it static below.  */
11556                     cp_pedwarn ("ISO C++ forbids initialization of member `%D'",
11557                                 declarator);
11558                     cp_pedwarn ("making `%D' static", declarator);
11559                     staticp = 1;
11560                   }
11561
11562                 if (uses_template_parms (type))
11563                   /* We'll check at instantiation time.  */
11564                   ;
11565                 else if (check_static_variable_definition (declarator,
11566                                                            type))
11567                   /* If we just return the declaration, crashes
11568                      will sometimes occur.  We therefore return
11569                      void_type_node, as if this was a friend
11570                      declaration, to cause callers to completely
11571                      ignore this declaration.  */
11572                   return void_type_node;
11573               }
11574
11575             /* 9.2p13 [class.mem] */
11576             if (declarator == constructor_name (current_class_type)
11577                 /* The standard does not allow non-static data members
11578                    here either, but we agreed at the 10/99 meeting
11579                    to change that in TC 1 so that they are allowed in
11580                    classes with no user-defined constructors.  */
11581                 && staticp)
11582               cp_pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
11583                           declarator);
11584
11585             if (staticp)
11586               {
11587                 /* C++ allows static class members.  All other work
11588                    for this is done by grokfield.  */
11589                 decl = build_lang_decl (VAR_DECL, declarator, type);
11590                 TREE_STATIC (decl) = 1;
11591                 /* In class context, 'static' means public access.  */
11592                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11593               }
11594             else
11595               {
11596                 decl = build_decl (FIELD_DECL, declarator, type);
11597                 TREE_ADDRESSABLE (decl) = ! bitfield;
11598                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11599                   {
11600                     DECL_MUTABLE_P (decl) = 1;
11601                     RIDBIT_RESET (RID_MUTABLE, specbits);
11602                   }
11603               }
11604
11605             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11606                             inlinep, friendp, raises != NULL_TREE);
11607           }
11608       }
11609     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11610       {
11611         tree original_name;
11612         int publicp = 0;
11613
11614         if (! declarator)
11615           return NULL_TREE;
11616
11617         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11618           original_name = dname;
11619         else
11620           original_name = declarator;
11621
11622         if (RIDBIT_SETP (RID_AUTO, specbits))
11623           error ("storage class `auto' invalid for function `%s'", name);
11624         else if (RIDBIT_SETP (RID_REGISTER, specbits))
11625           error ("storage class `register' invalid for function `%s'", name);
11626
11627         /* Function declaration not at top level.
11628            Storage classes other than `extern' are not allowed
11629            and `extern' makes no difference.  */
11630         if (! toplevel_bindings_p ()
11631             && (RIDBIT_SETP (RID_STATIC, specbits)
11632                 || RIDBIT_SETP (RID_INLINE, specbits))
11633             && pedantic)
11634           {
11635             if (RIDBIT_SETP (RID_STATIC, specbits))
11636               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11637             else
11638               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11639           }
11640
11641         if (ctype == NULL_TREE)
11642           {
11643             if (virtualp)
11644               {
11645                 error ("virtual non-class function `%s'", name);
11646                 virtualp = 0;
11647               }
11648           }
11649         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11650           type = build_cplus_method_type (ctype, TREE_TYPE (type),
11651                                           TYPE_ARG_TYPES (type));
11652
11653         /* Record presence of `static'.  */
11654         publicp = (ctype != NULL_TREE
11655                    || RIDBIT_SETP (RID_EXTERN, specbits)
11656                    || !RIDBIT_SETP (RID_STATIC, specbits));
11657
11658         decl = grokfndecl (ctype, type, original_name, declarator,
11659                            virtualp, flags, quals, raises,
11660                            1, friendp,
11661                            publicp, inlinep, funcdef_flag,
11662                            template_count, in_namespace);
11663         if (decl == NULL_TREE)
11664           return NULL_TREE;
11665
11666         if (staticp == 1)
11667           {
11668             int illegal_static = 0;
11669
11670             /* Don't allow a static member function in a class, and forbid
11671                declaring main to be static.  */
11672             if (TREE_CODE (type) == METHOD_TYPE)
11673               {
11674                 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11675                 illegal_static = 1;
11676               }
11677             else if (current_function_decl)
11678               {
11679                 /* FIXME need arm citation */
11680                 error ("cannot declare static function inside another function");
11681                 illegal_static = 1;
11682               }
11683
11684             if (illegal_static)
11685               {
11686                 staticp = 0;
11687                 RIDBIT_RESET (RID_STATIC, specbits);
11688               }
11689           }
11690       }
11691     else
11692       {
11693         /* It's a variable.  */
11694
11695         /* An uninitialized decl with `extern' is a reference.  */
11696         decl = grokvardecl (type, declarator, &specbits,
11697                             initialized,
11698                             (type_quals & TYPE_QUAL_CONST) != 0,
11699                             in_namespace);
11700         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11701                         inlinep, friendp, raises != NULL_TREE);
11702
11703         if (ctype)
11704           {
11705             DECL_CONTEXT (decl) = ctype;
11706             if (staticp == 1)
11707               {
11708                 cp_pedwarn ("static member `%D' re-declared as static", decl);
11709                 staticp = 0;
11710                 RIDBIT_RESET (RID_STATIC, specbits);
11711               }
11712             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11713               {
11714                 cp_error ("static member `%D' declared `register'", decl);
11715                 RIDBIT_RESET (RID_REGISTER, specbits);
11716               }
11717             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11718               {
11719                 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11720                             decl);
11721                 RIDBIT_RESET (RID_EXTERN, specbits);
11722               }
11723           }
11724       }
11725
11726     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11727
11728     /* Record `register' declaration for warnings on &
11729        and in case doing stupid register allocation.  */
11730
11731     if (RIDBIT_SETP (RID_REGISTER, specbits))
11732       DECL_REGISTER (decl) = 1;
11733
11734     if (RIDBIT_SETP (RID_EXTERN, specbits))
11735       DECL_THIS_EXTERN (decl) = 1;
11736
11737     if (RIDBIT_SETP (RID_STATIC, specbits))
11738       DECL_THIS_STATIC (decl) = 1;
11739
11740     /* Record constancy and volatility.  There's no need to do this
11741        when processing a template; we'll do this for the instantiated
11742        declaration based on the type of DECL.  */
11743     if (!processing_template_decl)
11744       c_apply_type_quals_to_decl (type_quals, decl);
11745
11746     return decl;
11747   }
11748 }
11749 \f
11750 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11751    An empty exprlist is a parmlist.  An exprlist which
11752    contains only identifiers at the global level
11753    is a parmlist.  Otherwise, it is an exprlist.  */
11754
11755 int
11756 parmlist_is_exprlist (exprs)
11757      tree exprs;
11758 {
11759   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11760     return 0;
11761
11762   if (toplevel_bindings_p ())
11763     {
11764       /* At the global level, if these are all identifiers,
11765          then it is a parmlist.  */
11766       while (exprs)
11767         {
11768           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11769             return 1;
11770           exprs = TREE_CHAIN (exprs);
11771         }
11772       return 0;
11773     }
11774   return 1;
11775 }
11776
11777 /* Subroutine of start_function.  Ensure that each of the parameter
11778    types (as listed in PARMS) is complete, as is required for a
11779    function definition.  */
11780
11781 static void
11782 require_complete_types_for_parms (parms)
11783      tree parms;
11784 {
11785   for (; parms; parms = TREE_CHAIN (parms))
11786     {
11787       tree type = TREE_TYPE (parms);
11788
11789       /* Try to complete the TYPE.  */
11790       type = complete_type (type);
11791
11792       if (type == error_mark_node)
11793         continue;
11794
11795       if (!COMPLETE_TYPE_P (type))
11796         {
11797           if (DECL_NAME (parms))
11798             error ("parameter `%s' has incomplete type",
11799                    IDENTIFIER_POINTER (DECL_NAME (parms)));
11800           else
11801             error ("parameter has incomplete type");
11802           TREE_TYPE (parms) = error_mark_node;
11803         }
11804       else
11805         layout_decl (parms, 0);
11806     }
11807 }
11808
11809 /* Returns non-zero if T is a local variable.  */
11810
11811 int
11812 local_variable_p (t)
11813      tree t;
11814 {
11815   if ((TREE_CODE (t) == VAR_DECL
11816        /* A VAR_DECL with a context that is a _TYPE is a static data
11817           member.  */
11818        && !TYPE_P (CP_DECL_CONTEXT (t))
11819        /* Any other non-local variable must be at namespace scope.  */
11820        && !DECL_NAMESPACE_SCOPE_P (t))
11821       || (TREE_CODE (t) == PARM_DECL))
11822     return 1;
11823
11824   return 0;
11825 }
11826
11827 /* Returns non-zero if T is an automatic local variable or a label.
11828    (These are the declarations that need to be remapped when the code
11829    containing them is duplicated.)  */
11830
11831 int
11832 nonstatic_local_decl_p (t)
11833      tree t;
11834 {
11835   return ((local_variable_p (t) && !TREE_STATIC (t))
11836           || TREE_CODE (t) == LABEL_DECL
11837           || TREE_CODE (t) == RESULT_DECL);
11838 }
11839
11840 /* Like local_variable_p, but suitable for use as a tree-walking
11841    function.  */
11842
11843 static tree
11844 local_variable_p_walkfn (tp, walk_subtrees, data)
11845      tree *tp;
11846      int *walk_subtrees ATTRIBUTE_UNUSED;
11847      void *data ATTRIBUTE_UNUSED;
11848 {
11849   return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
11850           ? *tp : NULL_TREE);
11851 }
11852
11853 /* Check that ARG, which is a default-argument expression for a
11854    parameter DECL, is legal.  Returns ARG, or ERROR_MARK_NODE, if
11855    something goes wrong.  DECL may also be a _TYPE node, rather than a
11856    DECL, if there is no DECL available.  */
11857
11858 tree
11859 check_default_argument (decl, arg)
11860      tree decl;
11861      tree arg;
11862 {
11863   tree var;
11864   tree decl_type;
11865
11866   if (TREE_CODE (arg) == DEFAULT_ARG)
11867     /* We get a DEFAULT_ARG when looking at an in-class declaration
11868        with a default argument.  Ignore the argument for now; we'll
11869        deal with it after the class is complete.  */
11870     return arg;
11871
11872   if (processing_template_decl || uses_template_parms (arg))
11873     /* We don't do anything checking until instantiation-time.  Note
11874        that there may be uninstantiated arguments even for an
11875        instantiated function, since default arguments are not
11876        instantiated until they are needed.  */
11877     return arg;
11878
11879   if (TYPE_P (decl))
11880     {
11881       decl_type = decl;
11882       decl = NULL_TREE;
11883     }
11884   else
11885     decl_type = TREE_TYPE (decl);
11886
11887   if (arg == error_mark_node
11888       || decl == error_mark_node
11889       || TREE_TYPE (arg) == error_mark_node
11890       || decl_type == error_mark_node)
11891     /* Something already went wrong.  There's no need to check
11892        further.  */
11893     return error_mark_node;
11894
11895   /* [dcl.fct.default]
11896
11897      A default argument expression is implicitly converted to the
11898      parameter type.  */
11899   if (!TREE_TYPE (arg)
11900       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
11901     {
11902       if (decl)
11903         cp_error ("default argument for `%#D' has type `%T'",
11904                   decl, TREE_TYPE (arg));
11905       else
11906         cp_error ("default argument for parameter of type `%T' has type `%T'",
11907                   decl_type, TREE_TYPE (arg));
11908
11909       return error_mark_node;
11910     }
11911
11912   /* [dcl.fct.default]
11913
11914      Local variables shall not be used in default argument
11915      expressions.
11916
11917      The keyword `this' shall not be used in a default argument of a
11918      member function.  */
11919   var = walk_tree (&arg, local_variable_p_walkfn, NULL);
11920   if (var)
11921     {
11922       cp_error ("default argument `%E' uses local variable `%D'",
11923                 arg, var);
11924       return error_mark_node;
11925     }
11926
11927   /* All is well.  */
11928   return arg;
11929 }
11930
11931 /* Decode the list of parameter types for a function type.
11932    Given the list of things declared inside the parens,
11933    return a list of types.
11934
11935    The list we receive can have three kinds of elements:
11936    an IDENTIFIER_NODE for names given without types,
11937    a TREE_LIST node for arguments given as typespecs or names with typespecs,
11938    or void_type_node, to mark the end of an argument list
11939    when additional arguments are not permitted (... was not used).
11940
11941    FUNCDEF_FLAG is nonzero for a function definition, 0 for
11942    a mere declaration.  A nonempty identifier-list gets an error message
11943    when FUNCDEF_FLAG is zero.
11944    If FUNCDEF_FLAG is 1, then parameter types must be complete.
11945    If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
11946
11947    If all elements of the input list contain types,
11948    we return a list of the types.
11949    If all elements contain no type (except perhaps a void_type_node
11950    at the end), we return a null list.
11951    If some have types and some do not, it is an error, and we
11952    return a null list.
11953
11954    Also set last_function_parms to either
11955    a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
11956    A list of names is converted to a chain of PARM_DECLs
11957    by store_parm_decls so that ultimately it is always a chain of decls.
11958
11959    Note that in C++, parameters can take default values.  These default
11960    values are in the TREE_PURPOSE field of the TREE_LIST.  It is
11961    an error to specify default values which are followed by parameters
11962    that have no default values, or an ELLIPSES.  For simplicities sake,
11963    only parameters which are specified with their types can take on
11964    default values.  */
11965
11966 static tree
11967 grokparms (first_parm, funcdef_flag)
11968      tree first_parm;
11969      int funcdef_flag;
11970 {
11971   tree result = NULL_TREE;
11972   tree decls = NULL_TREE;
11973
11974   if (first_parm != NULL_TREE
11975       && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
11976     {
11977       if (! funcdef_flag)
11978         pedwarn ("parameter names (without types) in function declaration");
11979       last_function_parms = first_parm;
11980       return NULL_TREE;
11981     }
11982   else if (first_parm != NULL_TREE
11983            && TREE_CODE (TREE_VALUE (first_parm)) != TREE_LIST
11984            && TREE_CODE (TREE_VALUE (first_parm)) != VOID_TYPE)
11985     my_friendly_abort (145);
11986   else
11987     {
11988       /* Types were specified.  This is a list of declarators
11989          each represented as a TREE_LIST node.  */
11990       register tree parm, chain;
11991       int any_init = 0, any_error = 0;
11992
11993       if (first_parm != NULL_TREE)
11994         {
11995           tree last_result = NULL_TREE;
11996           tree last_decl = NULL_TREE;
11997
11998           for (parm = first_parm; parm != NULL_TREE; parm = chain)
11999             {
12000               tree type = NULL_TREE, list_node = parm;
12001               register tree decl = TREE_VALUE (parm);
12002               tree init = TREE_PURPOSE (parm);
12003
12004               chain = TREE_CHAIN (parm);
12005               /* @@ weak defense against parse errors.  */
12006               if (TREE_CODE (decl) != VOID_TYPE
12007                   && TREE_CODE (decl) != TREE_LIST)
12008                 {
12009                   /* Give various messages as the need arises.  */
12010                   if (TREE_CODE (decl) == STRING_CST)
12011                     cp_error ("invalid string constant `%E'", decl);
12012                   else if (TREE_CODE (decl) == INTEGER_CST)
12013                     error ("invalid integer constant in parameter list, did you forget to give parameter name?");
12014                   continue;
12015                 }
12016
12017               if (TREE_CODE (decl) != VOID_TYPE)
12018                 {
12019                   decl = grokdeclarator (TREE_VALUE (decl),
12020                                          TREE_PURPOSE (decl),
12021                                          PARM, init != NULL_TREE,
12022                                          NULL_TREE);
12023                   if (! decl || TREE_TYPE (decl) == error_mark_node)
12024                     continue;
12025
12026                   /* Top-level qualifiers on the parameters are
12027                      ignored for function types.  */
12028                   type = TYPE_MAIN_VARIANT (TREE_TYPE (decl));
12029
12030                   if (TREE_CODE (type) == VOID_TYPE)
12031                     decl = void_type_node;
12032                   else if (TREE_CODE (type) == METHOD_TYPE)
12033                     {
12034                       if (DECL_NAME (decl))
12035                         /* Cannot use the decl here because
12036                            we don't have DECL_CONTEXT set up yet.  */
12037                         cp_error ("parameter `%D' invalidly declared method type",
12038                                   DECL_NAME (decl));
12039                       else
12040                         error ("parameter invalidly declared method type");
12041                       type = build_pointer_type (type);
12042                       TREE_TYPE (decl) = type;
12043                     }
12044                   else if (TREE_CODE (type) == OFFSET_TYPE)
12045                     {
12046                       if (DECL_NAME (decl))
12047                         cp_error ("parameter `%D' invalidly declared offset type",
12048                                   DECL_NAME (decl));
12049                       else
12050                         error ("parameter invalidly declared offset type");
12051                       type = build_pointer_type (type);
12052                       TREE_TYPE (decl) = type;
12053                     }
12054                   else if (abstract_virtuals_error (decl, type))
12055                     any_error = 1;  /* Seems like a good idea. */
12056                   else if (POINTER_TYPE_P (type))
12057                     {
12058                       tree t = type;
12059                       while (POINTER_TYPE_P (t)
12060                              || (TREE_CODE (t) == ARRAY_TYPE
12061                                  && TYPE_DOMAIN (t) != NULL_TREE))
12062                         t = TREE_TYPE (t);
12063                       if (TREE_CODE (t) == ARRAY_TYPE)
12064                         cp_error ("parameter type `%T' includes %s to array of unknown bound",
12065                                   type,
12066                                   TYPE_PTR_P (type) ? "pointer" : "reference");
12067                     }
12068                 }
12069
12070               if (TREE_CODE (decl) == VOID_TYPE)
12071                 {
12072                   if (result == NULL_TREE)
12073                     {
12074                       result = void_list_node;
12075                       last_result = result;
12076                     }
12077                   else
12078                     {
12079                       TREE_CHAIN (last_result) = void_list_node;
12080                       last_result = void_list_node;
12081                     }
12082                   if (chain
12083                       && (chain != void_list_node || TREE_CHAIN (chain)))
12084                     error ("`void' in parameter list must be entire list");
12085                   break;
12086                 }
12087
12088               /* Since there is a prototype, args are passed in their own types.  */
12089               DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
12090               if (PROMOTE_PROTOTYPES
12091                   && (TREE_CODE (type) == INTEGER_TYPE
12092                       || TREE_CODE (type) == ENUMERAL_TYPE)
12093                   && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
12094                 DECL_ARG_TYPE (decl) = integer_type_node;
12095               if (!any_error && init)
12096                 {
12097                   any_init++;
12098                   init = check_default_argument (decl, init);
12099                 }
12100               else
12101                 init = NULL_TREE;
12102
12103               if (decls == NULL_TREE)
12104                 {
12105                   decls = decl;
12106                   last_decl = decls;
12107                 }
12108               else
12109                 {
12110                   TREE_CHAIN (last_decl) = decl;
12111                   last_decl = decl;
12112                 }
12113               list_node = tree_cons (init, type, NULL_TREE);
12114               if (result == NULL_TREE)
12115                 {
12116                   result = list_node;
12117                   last_result = result;
12118                 }
12119               else
12120                 {
12121                   TREE_CHAIN (last_result) = list_node;
12122                   last_result = list_node;
12123                 }
12124             }
12125           if (last_result)
12126             TREE_CHAIN (last_result) = NULL_TREE;
12127           /* If there are no parameters, and the function does not end
12128              with `...', then last_decl will be NULL_TREE.  */
12129           if (last_decl != NULL_TREE)
12130             TREE_CHAIN (last_decl) = NULL_TREE;
12131         }
12132     }
12133
12134   last_function_parms = decls;
12135
12136   return result;
12137 }
12138
12139 /* Called from the parser to update an element of TYPE_ARG_TYPES for some
12140    FUNCTION_TYPE with the newly parsed version of its default argument, which
12141    was previously digested as text.  See snarf_defarg et al in lex.c.  */
12142
12143 void
12144 replace_defarg (arg, init)
12145      tree arg, init;
12146 {
12147   if (! processing_template_decl
12148       && ! can_convert_arg (TREE_VALUE (arg), TREE_TYPE (init), init))
12149     cp_pedwarn ("invalid type `%T' for default argument to `%T'",
12150                 TREE_TYPE (init), TREE_VALUE (arg));
12151   TREE_PURPOSE (arg) = init;
12152 }
12153 \f
12154 /* D is a constructor or overloaded `operator='.  Returns non-zero if
12155    D's arguments allow it to be a copy constructor, or copy assignment
12156    operator.  */
12157
12158 int
12159 copy_args_p (d)
12160      tree d;
12161 {
12162   tree t;
12163
12164   if (!DECL_FUNCTION_MEMBER_P (d))
12165     return 0;
12166
12167   t = FUNCTION_ARG_CHAIN (d);
12168   if (DECL_CONSTRUCTOR_P (d) && DECL_HAS_IN_CHARGE_PARM_P (d))
12169     t = TREE_CHAIN (t);
12170   if (t && TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
12171       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t)))
12172           == DECL_CONTEXT (d))
12173       && (TREE_CHAIN (t) == NULL_TREE
12174           || TREE_CHAIN (t) == void_list_node
12175           || TREE_PURPOSE (TREE_CHAIN (t))))
12176     return 1;
12177   return 0;
12178 }
12179
12180 /* These memoizing functions keep track of special properties which
12181    a class may have.  `grok_ctor_properties' notices whether a class
12182    has a constructor of the form X(X&), and also complains
12183    if the class has a constructor of the form X(X).
12184    `grok_op_properties' takes notice of the various forms of
12185    operator= which are defined, as well as what sorts of type conversion
12186    may apply.  Both functions take a FUNCTION_DECL as an argument.  */
12187
12188 int
12189 grok_ctor_properties (ctype, decl)
12190      tree ctype, decl;
12191 {
12192   tree parmtypes = FUNCTION_ARG_CHAIN (decl);
12193   tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
12194
12195   /* When a type has virtual baseclasses, a magical first int argument is
12196      added to any ctor so we can tell if the class has been initialized
12197      yet.  This could screw things up in this function, so we deliberately
12198      ignore the leading int if we're in that situation.  */
12199   if (DECL_HAS_IN_CHARGE_PARM_P (decl))
12200     {
12201       my_friendly_assert (parmtypes
12202                           && TREE_VALUE (parmtypes) == integer_type_node,
12203                           980529);
12204       parmtypes = TREE_CHAIN (parmtypes);
12205       parmtype = TREE_VALUE (parmtypes);
12206     }
12207
12208   /* [class.copy]
12209
12210      A non-template constructor for class X is a copy constructor if
12211      its first parameter is of type X&, const X&, volatile X& or const
12212      volatile X&, and either there are no other parameters or else all
12213      other parameters have default arguments.  */
12214   if (TREE_CODE (parmtype) == REFERENCE_TYPE
12215       && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype
12216       && (TREE_CHAIN (parmtypes) == NULL_TREE
12217           || TREE_CHAIN (parmtypes) == void_list_node
12218           || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
12219       && !(DECL_TEMPLATE_INSTANTIATION (decl)
12220            && is_member_template (DECL_TI_TEMPLATE (decl))))
12221     {
12222       TYPE_HAS_INIT_REF (ctype) = 1;
12223       if (CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12224         TYPE_HAS_CONST_INIT_REF (ctype) = 1;
12225     }
12226   /* [class.copy]
12227
12228      A declaration of a constructor for a class X is ill-formed if its
12229      first parameter is of type (optionally cv-qualified) X and either
12230      there are no other parameters or else all other parameters have
12231      default arguments.
12232
12233      We *don't* complain about member template instantiations that
12234      have this form, though; they can occur as we try to decide what
12235      constructor to use during overload resolution.  Since overload
12236      resolution will never prefer such a constructor to the
12237      non-template copy constructor (which is either explicitly or
12238      implicitly defined), there's no need to worry about their
12239      existence.  Theoretically, they should never even be
12240      instantiated, but that's hard to forestall.  */
12241   else if (TYPE_MAIN_VARIANT (parmtype) == ctype
12242            && (TREE_CHAIN (parmtypes) == NULL_TREE
12243                || TREE_CHAIN (parmtypes) == void_list_node
12244                || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
12245            && !(DECL_TEMPLATE_INSTANTIATION (decl)
12246                 && is_member_template (DECL_TI_TEMPLATE (decl))))
12247     {
12248       cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
12249                 ctype, ctype);
12250       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
12251       return 0;
12252     }
12253   else if (TREE_CODE (parmtype) == VOID_TYPE
12254            || TREE_PURPOSE (parmtypes) != NULL_TREE)
12255     TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
12256
12257   return 1;
12258 }
12259
12260 /* An operator with this code is unary, but can also be binary.  */
12261
12262 static int
12263 ambi_op_p (code)
12264      enum tree_code code;
12265 {
12266   return (code == INDIRECT_REF
12267           || code == ADDR_EXPR
12268           || code == CONVERT_EXPR
12269           || code == NEGATE_EXPR
12270           || code == PREINCREMENT_EXPR
12271           || code == PREDECREMENT_EXPR);
12272 }
12273
12274 /* An operator with this name can only be unary.  */
12275
12276 static int
12277 unary_op_p (code)
12278      enum tree_code code;
12279 {
12280   return (code == TRUTH_NOT_EXPR
12281           || code == BIT_NOT_EXPR
12282           || code == COMPONENT_REF
12283           || code == TYPE_EXPR);
12284 }
12285
12286 /* Do a little sanity-checking on how they declared their operator.  */
12287
12288 void
12289 grok_op_properties (decl, virtualp, friendp)
12290      tree decl;
12291      int virtualp, friendp;
12292 {
12293   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
12294   tree argtype;
12295   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
12296   tree name = DECL_NAME (decl);
12297   enum tree_code operator_code;
12298   int arity;
12299
12300   /* Count the number of arguments.  */
12301   for (argtype = argtypes, arity = 0;
12302        argtype && argtype != void_list_node;
12303        argtype = TREE_CHAIN (argtype))
12304     ++arity;
12305
12306   if (current_class_type == NULL_TREE)
12307     friendp = 1;
12308
12309   if (DECL_CONV_FN_P (decl))
12310     operator_code = TYPE_EXPR;
12311   else
12312     do
12313       {
12314 #define DEF_OPERATOR(NAME, CODE, NEW_MANGLING, OLD_MANGING, ARITY, ASSN_P)  \
12315         if (ansi_opname (CODE) == name)                                     \
12316           {                                                                 \
12317             operator_code = CODE;                                           \
12318             break;                                                          \
12319           }                                                                 \
12320         else if (ansi_assopname (CODE) == name)                             \
12321           {                                                                 \
12322             operator_code = CODE;                                           \
12323             DECL_ASSIGNMENT_OPERATOR_P (decl) = 1;                          \
12324             break;                                                          \
12325           }
12326
12327 #include "operators.def"
12328 #undef DEF_OPERATOR
12329
12330         my_friendly_abort (20000527);
12331       }
12332     while (0);
12333   my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526);
12334   SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12335
12336   if (! friendp)
12337     {
12338       switch (operator_code)
12339         {
12340         case CALL_EXPR:
12341           TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
12342           break;
12343
12344         case ARRAY_REF:
12345           TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
12346           break;
12347
12348         case COMPONENT_REF:
12349         case MEMBER_REF:
12350           TYPE_OVERLOADS_ARROW (current_class_type) = 1;
12351           break;
12352
12353         case NEW_EXPR:
12354           TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
12355           break;
12356
12357         case DELETE_EXPR:
12358           TYPE_GETS_DELETE (current_class_type) |= 1;
12359           break;
12360
12361         case VEC_NEW_EXPR:
12362           TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
12363           break;
12364
12365         case VEC_DELETE_EXPR:
12366           TYPE_GETS_DELETE (current_class_type) |= 2;
12367           break;
12368
12369         default:
12370           break;
12371         }
12372     }
12373
12374   if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
12375     {
12376       /* When the compiler encounters the definition of A::operator new, it
12377          doesn't look at the class declaration to find out if it's static.  */
12378       if (methodp)
12379         revert_static_member_fn (decl);
12380
12381       /* Take care of function decl if we had syntax errors.  */
12382       if (argtypes == NULL_TREE)
12383         TREE_TYPE (decl)
12384           = build_function_type (ptr_type_node,
12385                                  hash_tree_chain (integer_type_node,
12386                                                   void_list_node));
12387       else
12388         TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12389     }
12390   else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
12391     {
12392       if (methodp)
12393         revert_static_member_fn (decl);
12394
12395       if (argtypes == NULL_TREE)
12396         TREE_TYPE (decl)
12397           = build_function_type (void_type_node,
12398                                  hash_tree_chain (ptr_type_node,
12399                                                   void_list_node));
12400       else
12401         TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12402     }
12403   else
12404     {
12405       /* An operator function must either be a non-static member function
12406          or have at least one parameter of a class, a reference to a class,
12407          an enumeration, or a reference to an enumeration.  13.4.0.6 */
12408       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12409         {
12410           if (operator_code == TYPE_EXPR
12411               || operator_code == CALL_EXPR
12412               || operator_code == COMPONENT_REF
12413               || operator_code == ARRAY_REF
12414               || operator_code == NOP_EXPR)
12415             cp_error ("`%D' must be a nonstatic member function", decl);
12416           else
12417             {
12418               tree p = argtypes;
12419
12420               if (DECL_STATIC_FUNCTION_P (decl))
12421                 cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
12422
12423               if (p)
12424                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12425                   {
12426                     tree arg = TREE_VALUE (p);
12427                     if (TREE_CODE (arg) == REFERENCE_TYPE)
12428                       arg = TREE_TYPE (arg);
12429
12430                     /* This lets bad template code slip through.  */
12431                     if (IS_AGGR_TYPE (arg)
12432                         || TREE_CODE (arg) == ENUMERAL_TYPE
12433                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12434                         || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
12435                       goto foundaggr;
12436                   }
12437               cp_error
12438                 ("`%D' must have an argument of class or enumerated type",
12439                  decl);
12440             foundaggr:
12441               ;
12442             }
12443         }
12444
12445       if (operator_code == CALL_EXPR)
12446         return;                 /* No restrictions on args. */
12447
12448       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12449         {
12450           tree t = TREE_TYPE (name);
12451           if (! friendp)
12452             {
12453               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12454               const char *what = 0;
12455
12456               if (ref)
12457                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12458
12459               if (TREE_CODE (t) == VOID_TYPE)
12460                 what = "void";
12461               else if (t == current_class_type)
12462                 what = "the same type";
12463               /* Don't force t to be complete here.  */
12464               else if (IS_AGGR_TYPE (t)
12465                        && COMPLETE_TYPE_P (t)
12466                        && DERIVED_FROM_P (t, current_class_type))
12467                 what = "a base class";
12468
12469               if (what)
12470                 warning ("conversion to %s%s will never use a type conversion operator",
12471                          ref ? "a reference to " : "", what);
12472             }
12473         }
12474
12475       if (DECL_ASSIGNMENT_OPERATOR_P (decl)
12476           && operator_code == NOP_EXPR)
12477         {
12478           tree parmtype;
12479
12480           if (arity != 2 && methodp)
12481             {
12482               cp_error ("`%D' must take exactly one argument", decl);
12483               return;
12484             }
12485           parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
12486
12487           /* [class.copy]
12488
12489              A user-declared copy assignment operator X::operator= is
12490              a non-static non-template member function of class X with
12491              exactly one parameter of type X, X&, const X&, volatile
12492              X& or const volatile X&.  */
12493           if (copy_assignment_arg_p (parmtype, virtualp)
12494               && !(DECL_TEMPLATE_INSTANTIATION (decl)
12495                    && is_member_template (DECL_TI_TEMPLATE (decl)))
12496               && ! friendp)
12497             {
12498               TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
12499               if (TREE_CODE (parmtype) != REFERENCE_TYPE
12500                   || CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12501                 TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
12502             }
12503         }
12504       else if (operator_code == COND_EXPR)
12505         {
12506           /* 13.4.0.3 */
12507           cp_error ("ISO C++ prohibits overloading operator ?:");
12508         }
12509       else if (ambi_op_p (operator_code))
12510         {
12511           if (arity == 1)
12512             /* We pick the one-argument operator codes by default, so
12513                we don't have to change anything.  */
12514             ;
12515           else if (arity == 2)
12516             {
12517               /* If we thought this was a unary operator, we now know
12518                  it to be a binary operator.  */
12519               switch (operator_code)
12520                 {
12521                 case INDIRECT_REF:
12522                   operator_code = MULT_EXPR;
12523                   break;
12524
12525                 case ADDR_EXPR:
12526                   operator_code = BIT_AND_EXPR;
12527                   break;
12528
12529                 case CONVERT_EXPR:
12530                   operator_code = PLUS_EXPR;
12531                   break;
12532
12533                 case NEGATE_EXPR:
12534                   operator_code = MINUS_EXPR;
12535                   break;
12536
12537                 case PREINCREMENT_EXPR:
12538                   operator_code = POSTINCREMENT_EXPR;
12539                   break;
12540
12541                 case PREDECREMENT_EXPR:
12542                   operator_code = PREDECREMENT_EXPR;
12543                   break;
12544
12545                 default:
12546                   my_friendly_abort (20000527);
12547                 }
12548
12549               SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12550
12551               if ((operator_code == POSTINCREMENT_EXPR
12552                    || operator_code == POSTDECREMENT_EXPR)
12553                   && ! processing_template_decl
12554                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12555                 {
12556                   if (methodp)
12557                     cp_error ("postfix `%D' must take `int' as its argument",
12558                               decl);
12559                   else
12560                     cp_error
12561                       ("postfix `%D' must take `int' as its second argument",
12562                        decl);
12563                 }
12564             }
12565           else
12566             {
12567               if (methodp)
12568                 cp_error ("`%D' must take either zero or one argument", decl);
12569               else
12570                 cp_error ("`%D' must take either one or two arguments", decl);
12571             }
12572
12573           /* More Effective C++ rule 6.  */
12574           if (warn_ecpp
12575               && (operator_code == POSTINCREMENT_EXPR
12576                   || operator_code == POSTDECREMENT_EXPR
12577                   || operator_code == PREINCREMENT_EXPR
12578                   || operator_code == PREDECREMENT_EXPR))
12579             {
12580               tree arg = TREE_VALUE (argtypes);
12581               tree ret = TREE_TYPE (TREE_TYPE (decl));
12582               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12583                 arg = TREE_TYPE (arg);
12584               arg = TYPE_MAIN_VARIANT (arg);
12585               if (operator_code == PREINCREMENT_EXPR
12586                   || operator_code == PREDECREMENT_EXPR)
12587                 {
12588                   if (TREE_CODE (ret) != REFERENCE_TYPE
12589                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12590                                        arg))
12591                     cp_warning ("prefix `%D' should return `%T'", decl,
12592                                 build_reference_type (arg));
12593                 }
12594               else
12595                 {
12596                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12597                     cp_warning ("postfix `%D' should return `%T'", decl, arg);
12598                 }
12599             }
12600         }
12601       else if (unary_op_p (operator_code))
12602         {
12603           if (arity != 1)
12604             {
12605               if (methodp)
12606                 cp_error ("`%D' must take `void'", decl);
12607               else
12608                 cp_error ("`%D' must take exactly one argument", decl);
12609             }
12610         }
12611       else /* if (binary_op_p (operator_code)) */
12612         {
12613           if (arity != 2)
12614             {
12615               if (methodp)
12616                 cp_error ("`%D' must take exactly one argument", decl);
12617               else
12618                 cp_error ("`%D' must take exactly two arguments", decl);
12619             }
12620
12621           /* More Effective C++ rule 7.  */
12622           if (warn_ecpp
12623               && (operator_code == TRUTH_ANDIF_EXPR
12624                   || operator_code == TRUTH_ORIF_EXPR
12625                   || operator_code == COMPOUND_EXPR))
12626             cp_warning ("user-defined `%D' always evaluates both arguments",
12627                         decl);
12628         }
12629
12630       /* Effective C++ rule 23.  */
12631       if (warn_ecpp
12632           && arity == 2
12633           && (operator_code == PLUS_EXPR
12634               || operator_code == MINUS_EXPR
12635               || operator_code == TRUNC_DIV_EXPR
12636               || operator_code == MULT_EXPR)
12637           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12638         cp_warning ("`%D' should return by value", decl);
12639
12640       /* 13.4.0.8 */
12641       for (; argtypes && argtypes != void_list_node;
12642           argtypes = TREE_CHAIN (argtypes))
12643         if (TREE_PURPOSE (argtypes))
12644           {
12645             TREE_PURPOSE (argtypes) = NULL_TREE;
12646             if (operator_code == POSTINCREMENT_EXPR
12647                 || operator_code == POSTDECREMENT_EXPR)
12648               {
12649                 if (pedantic)
12650                   cp_pedwarn ("`%D' cannot have default arguments", decl);
12651               }
12652             else
12653               cp_error ("`%D' cannot have default arguments", decl);
12654           }
12655
12656     }
12657 }
12658 \f
12659 static const char *
12660 tag_name (code)
12661      enum tag_types code;
12662 {
12663   switch (code)
12664     {
12665     case record_type:
12666       return "struct";
12667     case class_type:
12668       return "class";
12669     case union_type:
12670       return "union ";
12671     case enum_type:
12672       return "enum";
12673     default:
12674       my_friendly_abort (981122);
12675     }
12676 }
12677
12678 /* Get the struct, enum or union (CODE says which) with tag NAME.
12679    Define the tag as a forward-reference if it is not defined.
12680
12681    C++: If a class derivation is given, process it here, and report
12682    an error if multiple derivation declarations are not identical.
12683
12684    If this is a definition, come in through xref_tag and only look in
12685    the current frame for the name (since C++ allows new names in any
12686    scope.)  */
12687
12688 tree
12689 xref_tag (code_type_node, name, globalize)
12690      tree code_type_node;
12691      tree name;
12692      int globalize;
12693 {
12694   enum tag_types tag_code;
12695   enum tree_code code;
12696   register tree ref, t;
12697   struct binding_level *b = current_binding_level;
12698   int got_type = 0;
12699   tree attributes = NULL_TREE;
12700   tree context = NULL_TREE;
12701
12702   /* If we are called from the parser, code_type_node will sometimes be a
12703      TREE_LIST.  This indicates that the user wrote
12704      "class __attribute__ ((foo)) bar".  Extract the attributes so we can
12705      use them later.  */
12706   if (TREE_CODE (code_type_node) == TREE_LIST)
12707     {
12708       attributes = TREE_PURPOSE (code_type_node);
12709       code_type_node = TREE_VALUE (code_type_node);
12710     }
12711
12712   tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12713   switch (tag_code)
12714     {
12715     case record_type:
12716     case class_type:
12717       code = RECORD_TYPE;
12718       break;
12719     case union_type:
12720       code = UNION_TYPE;
12721       break;
12722     case enum_type:
12723       code = ENUMERAL_TYPE;
12724       break;
12725     default:
12726       my_friendly_abort (18);
12727     }
12728
12729   /* If a cross reference is requested, look up the type
12730      already defined for this tag and return it.  */
12731   if (TYPE_P (name))
12732     {
12733       t = name;
12734       name = TYPE_IDENTIFIER (t);
12735       got_type = 1;
12736     }
12737   else
12738     t = IDENTIFIER_TYPE_VALUE (name);
12739
12740   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12741       && TREE_CODE (t) != TEMPLATE_TEMPLATE_PARM)
12742     t = NULL_TREE;
12743
12744   if (! globalize)
12745     {
12746       /* If we know we are defining this tag, only look it up in
12747          this scope and don't try to find it as a type.  */
12748       ref = lookup_tag (code, name, b, 1);
12749     }
12750   else
12751     {
12752       if (t)
12753         {
12754           /* [dcl.type.elab] If the identifier resolves to a
12755              typedef-name or a template type-parameter, the
12756              elaborated-type-specifier is ill-formed.  */
12757           if (t != TYPE_MAIN_VARIANT (t)
12758               || (CLASS_TYPE_P (t) && TYPE_WAS_ANONYMOUS (t)))
12759             cp_pedwarn ("using typedef-name `%D' after `%s'",
12760                         TYPE_NAME (t), tag_name (tag_code));
12761           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12762             cp_error ("using template type parameter `%T' after `%s'",
12763                       t, tag_name (tag_code));
12764
12765           ref = t;
12766         }
12767       else
12768         ref = lookup_tag (code, name, b, 0);
12769
12770       if (! ref)
12771         {
12772           /* Try finding it as a type declaration.  If that wins,
12773              use it.  */
12774           ref = lookup_name (name, 1);
12775
12776           if (ref != NULL_TREE
12777               && processing_template_decl
12778               && DECL_CLASS_TEMPLATE_P (ref)
12779               && template_class_depth (current_class_type) == 0)
12780             /* Since GLOBALIZE is true, we're declaring a global
12781                template, so we want this type.  */
12782             ref = DECL_TEMPLATE_RESULT (ref);
12783
12784           if (ref && TREE_CODE (ref) == TYPE_DECL
12785               && TREE_CODE (TREE_TYPE (ref)) == code)
12786             ref = TREE_TYPE (ref);
12787           else
12788             ref = NULL_TREE;
12789         }
12790
12791       if (ref && current_class_type
12792           && template_class_depth (current_class_type)
12793           && PROCESSING_REAL_TEMPLATE_DECL_P ())
12794         {
12795           /* Since GLOBALIZE is non-zero, we are not looking at a
12796              definition of this tag.  Since, in addition, we are currently
12797              processing a (member) template declaration of a template
12798              class, we must be very careful; consider:
12799
12800                template <class X>
12801                struct S1
12802
12803                template <class U>
12804                struct S2
12805                { template <class V>
12806                friend struct S1; };
12807
12808              Here, the S2::S1 declaration should not be confused with the
12809              outer declaration.  In particular, the inner version should
12810              have a template parameter of level 2, not level 1.  This
12811              would be particularly important if the member declaration
12812              were instead:
12813
12814                template <class V = U> friend struct S1;
12815
12816              say, when we should tsubst into `U' when instantiating
12817              S2.  On the other hand, when presented with:
12818
12819                  template <class T>
12820                  struct S1 {
12821                    template <class U>
12822                    struct S2 {};
12823                    template <class U>
12824                    friend struct S2;
12825                  };
12826
12827               we must find the inner binding eventually.  We
12828               accomplish this by making sure that the new type we
12829               create to represent this declaration has the right
12830               TYPE_CONTEXT.  */
12831           context = TYPE_CONTEXT (ref);
12832           ref = NULL_TREE;
12833         }
12834     }
12835
12836   if (! ref)
12837     {
12838       /* If no such tag is yet defined, create a forward-reference node
12839          and record it as the "definition".
12840          When a real declaration of this type is found,
12841          the forward-reference will be altered into a real type.  */
12842       if (code == ENUMERAL_TYPE)
12843         {
12844           cp_error ("use of enum `%#D' without previous declaration", name);
12845
12846           ref = make_node (ENUMERAL_TYPE);
12847
12848           /* Give the type a default layout like unsigned int
12849              to avoid crashing if it does not get defined.  */
12850           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12851           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12852           TREE_UNSIGNED (ref) = 1;
12853           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12854           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12855           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12856
12857           /* Enable us to recognize when a type is created in class context.
12858              To do nested classes correctly, this should probably be cleared
12859              out when we leave this classes scope.  Currently this in only
12860              done in `start_enum'.  */
12861
12862           pushtag (name, ref, globalize);
12863         }
12864       else
12865         {
12866           struct binding_level *old_b = class_binding_level;
12867
12868           ref = make_aggr_type (code);
12869           TYPE_CONTEXT (ref) = context;
12870
12871 #ifdef NONNESTED_CLASSES
12872           /* Class types don't nest the way enums do.  */
12873           class_binding_level = (struct binding_level *)0;
12874 #endif
12875           pushtag (name, ref, globalize);
12876           class_binding_level = old_b;
12877         }
12878     }
12879   else
12880     {
12881       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12882         redeclare_class_template (ref, current_template_parms);
12883     }
12884
12885   /* Until the type is defined, tentatively accept whatever
12886      structure tag the user hands us.  */
12887   if (!COMPLETE_TYPE_P (ref)
12888       && ref != current_class_type
12889       /* Have to check this, in case we have contradictory tag info.  */
12890       && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
12891     {
12892       if (tag_code == class_type)
12893         CLASSTYPE_DECLARED_CLASS (ref) = 1;
12894       else if (tag_code == record_type)
12895         CLASSTYPE_DECLARED_CLASS (ref) = 0;
12896     }
12897
12898   TREE_TYPE (ref) = attributes;
12899
12900   return ref;
12901 }
12902
12903 tree
12904 xref_tag_from_type (old, id, globalize)
12905      tree old, id;
12906      int globalize;
12907 {
12908   tree code_type_node;
12909
12910   if (TREE_CODE (old) == RECORD_TYPE)
12911     code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
12912                       ? class_type_node : record_type_node);
12913   else
12914     code_type_node = union_type_node;
12915
12916   if (id == NULL_TREE)
12917     id = TYPE_IDENTIFIER (old);
12918
12919   return xref_tag (code_type_node, id, globalize);
12920 }
12921
12922 /* REF is a type (named NAME), for which we have just seen some
12923    baseclasses.  BINFO is a list of those baseclasses; the
12924    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12925    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
12926    struct, or union.  */
12927
12928 void
12929 xref_basetypes (code_type_node, name, ref, binfo)
12930      tree code_type_node;
12931      tree name, ref;
12932      tree binfo;
12933 {
12934   /* In the declaration `A : X, Y, ... Z' we mark all the types
12935      (A, X, Y, ..., Z) so we can check for duplicates.  */
12936   tree binfos;
12937   tree base;
12938
12939   int i, len;
12940   enum tag_types tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12941
12942   if (tag_code == union_type)
12943     {
12944       cp_error ("derived union `%T' invalid", ref);
12945       return;
12946     }
12947
12948   len = list_length (binfo);
12949
12950   /* First, make sure that any templates in base-classes are
12951      instantiated.  This ensures that if we call ourselves recursively
12952      we do not get confused about which classes are marked and which
12953      are not.  */
12954   for (base = binfo; base; base = TREE_CHAIN (base))
12955     complete_type (TREE_VALUE (base));
12956
12957   SET_CLASSTYPE_MARKED (ref);
12958   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
12959
12960   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
12961     {
12962       /* The base of a derived struct is public by default.  */
12963       int via_public
12964         = (TREE_PURPOSE (binfo) == access_public_node
12965            || TREE_PURPOSE (binfo) == access_public_virtual_node
12966            || (tag_code != class_type
12967                && (TREE_PURPOSE (binfo) == access_default_node
12968                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
12969       int via_protected
12970         = (TREE_PURPOSE (binfo) == access_protected_node
12971            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
12972       int via_virtual
12973         = (TREE_PURPOSE (binfo) == access_private_virtual_node
12974            || TREE_PURPOSE (binfo) == access_protected_virtual_node
12975            || TREE_PURPOSE (binfo) == access_public_virtual_node
12976            || TREE_PURPOSE (binfo) == access_default_virtual_node);
12977       tree basetype = TREE_VALUE (binfo);
12978       tree base_binfo;
12979
12980       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
12981         basetype = TREE_TYPE (basetype);
12982       if (!basetype
12983           || (TREE_CODE (basetype) != RECORD_TYPE
12984               && TREE_CODE (basetype) != TYPENAME_TYPE
12985               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
12986               && TREE_CODE (basetype) != TEMPLATE_TEMPLATE_PARM))
12987         {
12988           cp_error ("base type `%T' fails to be a struct or class type",
12989                     TREE_VALUE (binfo));
12990           continue;
12991         }
12992
12993       GNU_xref_hier (name, basetype, via_public, via_virtual, 0);
12994
12995       /* This code replaces similar code in layout_basetypes.
12996          We put the complete_type first for implicit `typename'.  */
12997       if (!COMPLETE_TYPE_P (basetype)
12998           && ! (current_template_parms && uses_template_parms (basetype)))
12999         {
13000           cp_error ("base class `%T' has incomplete type", basetype);
13001           continue;
13002         }
13003       else
13004         {
13005           if (CLASSTYPE_MARKED (basetype))
13006             {
13007               if (basetype == ref)
13008                 cp_error ("recursive type `%T' undefined", basetype);
13009               else
13010                 cp_error ("duplicate base type `%T' invalid", basetype);
13011               continue;
13012             }
13013
13014           if (TYPE_FOR_JAVA (basetype)
13015               && (current_lang_stack
13016                   == &VARRAY_TREE (current_lang_base, 0)))
13017             TYPE_FOR_JAVA (ref) = 1;
13018
13019           /* Note that the BINFO records which describe individual
13020              inheritances are *not* shared in the lattice!  They
13021              cannot be shared because a given baseclass may be
13022              inherited with different `accessibility' by different
13023              derived classes.  (Each BINFO record describing an
13024              individual inheritance contains flags which say what
13025              the `accessibility' of that particular inheritance is.)  */
13026
13027           base_binfo
13028             = make_binfo (size_zero_node, basetype,
13029                           CLASS_TYPE_P (basetype)
13030                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
13031                           CLASS_TYPE_P (basetype)
13032                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
13033
13034           TREE_VEC_ELT (binfos, i) = base_binfo;
13035           TREE_VIA_PUBLIC (base_binfo) = via_public;
13036           TREE_VIA_PROTECTED (base_binfo) = via_protected;
13037           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
13038           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
13039
13040           /* We need to unshare the binfos now so that lookups during class
13041              definition work.  */
13042           unshare_base_binfos (base_binfo);
13043
13044           SET_CLASSTYPE_MARKED (basetype);
13045
13046           /* We are free to modify these bits because they are meaningless
13047              at top level, and BASETYPE is a top-level type.  */
13048           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
13049             {
13050               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
13051               /* Converting to a virtual base class requires looking
13052                  up the offset of the virtual base.  */
13053               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13054             }
13055
13056           if (CLASS_TYPE_P (basetype))
13057             {
13058               TYPE_HAS_NEW_OPERATOR (ref)
13059                 |= TYPE_HAS_NEW_OPERATOR (basetype);
13060               TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
13061                 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
13062               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
13063               /* If the base-class uses multiple inheritance, so do we.  */
13064               TYPE_USES_MULTIPLE_INHERITANCE (ref)
13065                 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
13066               /* Likewise, if converting to a base of the base may require
13067                  code, then we may need to generate code to convert to a
13068                  base as well.  */
13069               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
13070                 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
13071             }
13072
13073           i += 1;
13074         }
13075     }
13076   if (i)
13077     TREE_VEC_LENGTH (binfos) = i;
13078   else
13079     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
13080
13081   if (i > 1)
13082     {
13083       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
13084       /* If there is more than one non-empty they cannot be at the same
13085          address.  */
13086       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13087     }
13088
13089   /* Unmark all the types.  */
13090   while (--i >= 0)
13091     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
13092   CLEAR_CLASSTYPE_MARKED (ref);
13093
13094   /* Now that we know all the base-classes, set up the list of virtual
13095      bases.  */
13096   get_vbase_types (ref);
13097 }
13098
13099 \f
13100 /* Begin compiling the definition of an enumeration type.
13101    NAME is its name (or null if anonymous).
13102    Returns the type object, as yet incomplete.
13103    Also records info about it so that build_enumerator
13104    may be used to declare the individual values as they are read.  */
13105
13106 tree
13107 start_enum (name)
13108      tree name;
13109 {
13110   register tree enumtype = NULL_TREE;
13111   struct binding_level *b = current_binding_level;
13112
13113   /* If this is the real definition for a previous forward reference,
13114      fill in the contents in the same object that used to be the
13115      forward reference.  */
13116
13117   if (name != NULL_TREE)
13118     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
13119
13120   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
13121     {
13122       cp_error ("multiple definition of `%#T'", enumtype);
13123       cp_error_at ("previous definition here", enumtype);
13124       /* Clear out TYPE_VALUES, and start again.  */
13125       TYPE_VALUES (enumtype) = NULL_TREE;
13126     }
13127   else
13128     {
13129       enumtype = make_node (ENUMERAL_TYPE);
13130       pushtag (name, enumtype, 0);
13131     }
13132
13133   if (current_class_type)
13134     TREE_ADDRESSABLE (b->tags) = 1;
13135
13136   GNU_xref_decl (current_function_decl, enumtype);
13137   return enumtype;
13138 }
13139
13140 /* After processing and defining all the values of an enumeration type,
13141    install their decls in the enumeration type and finish it off.
13142    ENUMTYPE is the type object and VALUES a list of name-value pairs.
13143    Returns ENUMTYPE.  */
13144
13145 tree
13146 finish_enum (enumtype)
13147      tree enumtype;
13148 {
13149   register tree minnode = NULL_TREE, maxnode = NULL_TREE;
13150   /* Calculate the maximum value of any enumerator in this type.  */
13151
13152   tree values = TYPE_VALUES (enumtype);
13153   if (values)
13154     {
13155       tree pair;
13156
13157       for (pair = values; pair; pair = TREE_CHAIN (pair))
13158         {
13159           tree decl;
13160           tree value;
13161
13162           /* The TREE_VALUE is a CONST_DECL for this enumeration
13163              constant.  */
13164           decl = TREE_VALUE (pair);
13165
13166           /* [dcl.enum]
13167
13168              Following the closing brace of an enum-specifier, each
13169              enumerator has the type of its enumeration.  Prior to the
13170              closing brace, the type of each enumerator is the type of
13171              its initializing value.  */
13172           TREE_TYPE (decl) = enumtype;
13173
13174           /* The DECL_INITIAL will be NULL if we are processing a
13175              template declaration and this enumeration constant had no
13176              explicit initializer.  */
13177           value = DECL_INITIAL (decl);
13178           if (value && !processing_template_decl)
13179             {
13180               /* Set the TREE_TYPE for the VALUE as well.  That's so
13181                  that when we call decl_constant_value we get an
13182                  entity of the right type (but with the constant
13183                  value).  Since we shouldn't ever call
13184                  decl_constant_value on a template type, there's no
13185                  reason to do that when processing_template_decl.
13186                  And, if the expression is something like a
13187                  TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will
13188                  wreak havoc on the intended type of the expression.
13189
13190                  Of course, there's also no point in trying to compute
13191                  minimum or maximum values if we're in a template.  */
13192               TREE_TYPE (value) = enumtype;
13193
13194               if (!minnode)
13195                 minnode = maxnode = value;
13196               else if (tree_int_cst_lt (maxnode, value))
13197                 maxnode = value;
13198               else if (tree_int_cst_lt (value, minnode))
13199                 minnode = value;
13200             }
13201
13202           if (processing_template_decl)
13203             /* If this is just a template, leave the CONST_DECL
13204                alone.  That way tsubst_copy will find CONST_DECLs for
13205                CONST_DECLs, and not INTEGER_CSTs.  */
13206             ;
13207           else
13208             /* In the list we're building up, we want the enumeration
13209                values, not the CONST_DECLs.  */
13210             TREE_VALUE (pair) = value;
13211         }
13212     }
13213   else
13214     maxnode = minnode = integer_zero_node;
13215
13216   TYPE_VALUES (enumtype) = nreverse (values);
13217
13218   if (processing_template_decl)
13219     {
13220       tree scope = current_scope ();
13221       if (scope && TREE_CODE (scope) == FUNCTION_DECL)
13222         add_tree (build_min (TAG_DEFN, enumtype));
13223     }
13224   else
13225     {
13226       int unsignedp = tree_int_cst_sgn (minnode) >= 0;
13227       int lowprec = min_precision (minnode, unsignedp);
13228       int highprec = min_precision (maxnode, unsignedp);
13229       int precision = MAX (lowprec, highprec);
13230       tree tem;
13231
13232       TYPE_SIZE (enumtype) = NULL_TREE;
13233
13234       /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
13235
13236       TYPE_PRECISION (enumtype) = precision;
13237       if (unsignedp)
13238         fixup_unsigned_type (enumtype);
13239       else
13240         fixup_signed_type (enumtype);
13241
13242       if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
13243         /* Use the width of the narrowest normal C type which is wide
13244            enough.  */
13245         TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
13246                                                     (precision, 1));
13247       else
13248         TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
13249
13250       TYPE_SIZE (enumtype) = 0;
13251       layout_type (enumtype);
13252
13253       /* Fix up all variant types of this enum type.  */
13254       for (tem = TYPE_MAIN_VARIANT (enumtype); tem;
13255            tem = TYPE_NEXT_VARIANT (tem))
13256         {
13257           TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
13258           TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
13259           TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
13260           TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
13261           TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
13262           TYPE_MODE (tem) = TYPE_MODE (enumtype);
13263           TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
13264           TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
13265           TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
13266         }
13267
13268       /* Finish debugging output for this type.  */
13269       rest_of_type_compilation (enumtype, namespace_bindings_p ());
13270     }
13271
13272   return enumtype;
13273 }
13274
13275 /* Build and install a CONST_DECL for an enumeration constant of the
13276    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13277    Assignment of sequential values by default is handled here.  */
13278
13279 void
13280 build_enumerator (name, value, enumtype)
13281      tree name;
13282      tree value;
13283      tree enumtype;
13284 {
13285   tree decl;
13286   tree context;
13287   tree type;
13288   tree values;
13289
13290   /* Remove no-op casts from the value.  */
13291   if (value)
13292     STRIP_TYPE_NOPS (value);
13293
13294   if (! processing_template_decl)
13295     {
13296       /* Validate and default VALUE.  */
13297       if (value != NULL_TREE)
13298         {
13299           value = decl_constant_value (value);
13300
13301           if (TREE_CODE (value) == INTEGER_CST)
13302             {
13303               value = default_conversion (value);
13304               constant_expression_warning (value);
13305             }
13306           else
13307             {
13308               cp_error ("enumerator value for `%D' not integer constant", name);
13309               value = NULL_TREE;
13310             }
13311         }
13312
13313       /* Default based on previous value.  */
13314       if (value == NULL_TREE && ! processing_template_decl)
13315         {
13316           tree prev_value;
13317
13318           if (TYPE_VALUES (enumtype))
13319             {
13320               /* The next value is the previous value ... */
13321               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
13322               /* ... plus one.  */
13323               value = build_binary_op (PLUS_EXPR,
13324                                        prev_value,
13325                                        integer_one_node);
13326
13327               if (tree_int_cst_lt (value, prev_value))
13328                 cp_error ("overflow in enumeration values at `%D'", name);
13329             }
13330           else
13331             value = integer_zero_node;
13332         }
13333
13334       /* Remove no-op casts from the value.  */
13335       if (value)
13336         STRIP_TYPE_NOPS (value);
13337 #if 0
13338       /* To fix MAX_VAL enum consts. (bkoz)  */
13339       TREE_TYPE (value) = integer_type_node;
13340 #endif
13341     }
13342
13343   /* We always have to copy here; not all INTEGER_CSTs are unshared.
13344      Even in other cases, we will later (in finish_enum) be setting
13345      the type of VALUE.  But, we don't need to make a copy if this
13346      VALUE is one of the enumeration constants for this same
13347      enumeration type.  */
13348   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
13349     if (TREE_VALUE (values) == value)
13350       break;
13351   /* If we didn't break out of the loop, then we do need a copy.  */
13352   if (!values && value)
13353     value = copy_node (value);
13354
13355   /* C++ associates enums with global, function, or class declarations.  */
13356   context = current_scope ();
13357
13358   /* Build the actual enumeration constant.  Note that the enumeration
13359     constants have the type of their initializers until the
13360     enumeration is complete:
13361
13362       [ dcl.enum ]
13363
13364       Following the closing brace of an enum-specifier, each enumer-
13365       ator has the type of its enumeration.  Prior to the closing
13366       brace, the type of each enumerator is the type of its
13367       initializing value.
13368
13369     In finish_enum we will reset the type.  Of course, if we're
13370     processing a template, there may be no value.   */
13371   type = value ? TREE_TYPE (value) : NULL_TREE;
13372
13373   if (context && context == current_class_type)
13374     /* This enum declaration is local to the class.  We need the full
13375       lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
13376     decl = build_lang_decl (CONST_DECL, name, type);
13377   else
13378     /* It's a global enum, or it's local to a function.  (Note local to
13379       a function could mean local to a class method.  */
13380     decl = build_decl (CONST_DECL, name, type);
13381
13382   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
13383   DECL_INITIAL (decl) = value;
13384   TREE_READONLY (decl) = 1;
13385
13386   if (context && context == current_class_type)
13387     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13388       on the TYPE_FIELDS list for `S'.  (That's so that you can say
13389       things like `S::i' later.)  */
13390     finish_member_declaration (decl);
13391   else
13392     {
13393       pushdecl (decl);
13394       GNU_xref_decl (current_function_decl, decl);
13395     }
13396
13397   /* Add this enumeration constant to the list for this type.  */
13398   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13399 }
13400
13401 \f
13402 static int function_depth;
13403
13404 /* We're defining DECL.  Make sure that it's type is OK.  */
13405
13406 static void
13407 check_function_type (decl)
13408      tree decl;
13409 {
13410   tree fntype = TREE_TYPE (decl);
13411   tree return_type = complete_type (TREE_TYPE (fntype));
13412
13413   /* In a function definition, arg types must be complete.  */
13414   require_complete_types_for_parms (current_function_parms);
13415
13416   if (!COMPLETE_OR_VOID_TYPE_P (return_type))
13417     {
13418       cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
13419
13420       /* Make it return void instead, but don't change the
13421          type of the DECL_RESULT, in case we have a named return value.  */
13422       if (TREE_CODE (fntype) == METHOD_TYPE)
13423         {
13424           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
13425           TREE_TYPE (decl)
13426             = build_cplus_method_type (ctype,
13427                                        void_type_node,
13428                                        FUNCTION_ARG_CHAIN (decl));
13429         }
13430       else
13431         TREE_TYPE (decl)
13432           = build_function_type (void_type_node,
13433                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
13434       TREE_TYPE (decl)
13435         = build_exception_variant (fntype,
13436                                    TYPE_RAISES_EXCEPTIONS (fntype));
13437     }
13438   else
13439     abstract_virtuals_error (decl, TREE_TYPE (fntype));
13440 }
13441
13442 /* Create the FUNCTION_DECL for a function definition.
13443    DECLSPECS and DECLARATOR are the parts of the declaration;
13444    they describe the function's name and the type it returns,
13445    but twisted together in a fashion that parallels the syntax of C.
13446
13447    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13448    DECLARATOR is really the DECL for the function we are about to
13449    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13450    indicating that the function is an inline defined in-class, and
13451    SF_EXPAND indicating that we should generate RTL for this
13452    function.
13453
13454    This function creates a binding context for the function body
13455    as well as setting up the FUNCTION_DECL in current_function_decl.
13456
13457    Returns 1 on success.  If the DECLARATOR is not suitable for a function
13458    (it defines a datum instead), we return 0, which tells
13459    yyparse to report a parse error.
13460
13461    For C++, we must first check whether that datum makes any sense.
13462    For example, "class A local_a(1,2);" means that variable local_a
13463    is an aggregate of type A, which should have a constructor
13464    applied to it with the argument list [1, 2].  */
13465
13466 int
13467 start_function (declspecs, declarator, attrs, flags)
13468      tree declspecs, declarator, attrs;
13469      int flags;
13470 {
13471   tree decl1;
13472   tree ctype = NULL_TREE;
13473   tree fntype;
13474   tree restype;
13475   extern int have_extern_spec;
13476   extern int used_extern_spec;
13477   int doing_friend = 0;
13478   struct binding_level *bl;
13479
13480   /* Sanity check.  */
13481   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
13482   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
13483
13484   /* This should only be done once on the top most decl.  */
13485   if (have_extern_spec && !used_extern_spec)
13486     {
13487       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
13488       used_extern_spec = 1;
13489     }
13490
13491   if (flags & SF_PRE_PARSED)
13492     {
13493       decl1 = declarator;
13494
13495       fntype = TREE_TYPE (decl1);
13496       if (TREE_CODE (fntype) == METHOD_TYPE)
13497         ctype = TYPE_METHOD_BASETYPE (fntype);
13498
13499       /* ISO C++ 11.4/5.  A friend function defined in a class is in
13500          the (lexical) scope of the class in which it is defined.  */
13501       if (!ctype && DECL_FRIEND_P (decl1))
13502         {
13503           ctype = DECL_FRIEND_CONTEXT (decl1);
13504
13505           /* CTYPE could be null here if we're dealing with a template;
13506              for example, `inline friend float foo()' inside a template
13507              will have no CTYPE set.  */
13508           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13509             ctype = NULL_TREE;
13510           else
13511             doing_friend = 1;
13512         }
13513
13514       last_function_parms = DECL_ARGUMENTS (decl1);
13515       last_function_parm_tags = NULL_TREE;
13516     }
13517   else
13518     {
13519       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL_TREE);
13520       /* If the declarator is not suitable for a function definition,
13521          cause a syntax error.  */
13522       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
13523
13524       fntype = TREE_TYPE (decl1);
13525
13526       restype = TREE_TYPE (fntype);
13527       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13528         {
13529           cp_error ("semicolon missing after declaration of `%#T'", restype);
13530           shadow_tag (build_tree_list (NULL_TREE, restype));
13531           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13532           if (TREE_CODE (fntype) == FUNCTION_TYPE)
13533             fntype = build_function_type (integer_type_node,
13534                                           TYPE_ARG_TYPES (fntype));
13535           else
13536             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13537                                               integer_type_node,
13538                                               TYPE_ARG_TYPES (fntype));
13539           TREE_TYPE (decl1) = fntype;
13540         }
13541
13542       if (TREE_CODE (fntype) == METHOD_TYPE)
13543         ctype = TYPE_METHOD_BASETYPE (fntype);
13544       else if (DECL_MAIN_P (decl1))
13545         {
13546           /* If this doesn't return integer_type, complain.  */
13547           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13548             {
13549               if (pedantic || warn_return_type)
13550                 pedwarn ("return type for `main' changed to `int'");
13551               TREE_TYPE (decl1) = fntype = default_function_type;
13552             }
13553         }
13554     }
13555
13556   /* Sometimes we don't notice that a function is a static member, and
13557      build a METHOD_TYPE for it.  Fix that up now.  */
13558   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13559       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13560     {
13561       revert_static_member_fn (decl1);
13562       last_function_parms = TREE_CHAIN (last_function_parms);
13563       ctype = NULL_TREE;
13564     }
13565
13566   /* Warn if function was previously implicitly declared
13567      (but not if we warned then).  */
13568   if (! warn_implicit
13569       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13570     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13571
13572   /* Set up current_class_type, and enter the scope of the class, if
13573      appropriate.  */
13574   if (ctype)
13575     push_nested_class (ctype, 1);
13576   else if (DECL_STATIC_FUNCTION_P (decl1))
13577     push_nested_class (DECL_CONTEXT (decl1), 2);
13578
13579   /* Now that we have entered the scope of the class, we must restore
13580      the bindings for any template parameters surrounding DECL1, if it
13581      is an inline member template.  (Order is important; consider the
13582      case where a template parameter has the same name as a field of
13583      the class.)  It is not until after this point that
13584      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
13585   if (flags & SF_INCLASS_INLINE)
13586     maybe_begin_member_template_processing (decl1);
13587
13588   /* Effective C++ rule 15.  See also c_expand_return.  */
13589   if (warn_ecpp
13590       && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
13591       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13592     cp_warning ("`operator=' should return a reference to `*this'");
13593
13594   /* Make the init_value nonzero so pushdecl knows this is not tentative.
13595      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
13596   if (!DECL_INITIAL (decl1))
13597     DECL_INITIAL (decl1) = error_mark_node;
13598
13599 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
13600   SET_DEFAULT_DECL_ATTRIBUTES (decl1, attrs);
13601 #endif
13602
13603   /* This function exists in static storage.
13604      (This does not mean `static' in the C sense!)  */
13605   TREE_STATIC (decl1) = 1;
13606
13607   /* We must call push_template_decl after current_class_type is set
13608      up.  (If we are processing inline definitions after exiting a
13609      class scope, current_class_type will be NULL_TREE until set above
13610      by push_nested_class.)  */
13611   if (processing_template_decl)
13612     decl1 = push_template_decl (decl1);
13613
13614   /* We are now in the scope of the function being defined.  */
13615   current_function_decl = decl1;
13616
13617   /* Save the parm names or decls from this function's declarator
13618      where store_parm_decls will find them.  */
13619   current_function_parms = last_function_parms;
13620   current_function_parm_tags = last_function_parm_tags;
13621
13622   /* Make sure the parameter and return types are reasonable.  When
13623      you declare a function, these types can be incomplete, but they
13624      must be complete when you define the function.  */
13625   if (! processing_template_decl)
13626     check_function_type (decl1);
13627
13628   /* Build the return declaration for the function.  */
13629   restype = TREE_TYPE (fntype);
13630   if (!processing_template_decl)
13631     {
13632       if (!DECL_RESULT (decl1))
13633         {
13634           DECL_RESULT (decl1)
13635             = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13636           c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype),
13637                                       DECL_RESULT (decl1));
13638         }
13639     }
13640   else
13641     /* Just use `void'.  Nobody will ever look at this anyhow.  */
13642     DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, void_type_node);
13643
13644   /* Initialize RTL machinery.  We cannot do this until
13645      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
13646      even when processing a template; this is how we get
13647      CFUN set up, and our per-function variables initialized.  */
13648   bl = current_binding_level;
13649   init_function_start (decl1, input_filename, lineno);
13650   current_binding_level = bl;
13651   expanding_p = (flags & SF_EXPAND) != 0;
13652
13653   /* Even though we're inside a function body, we still don't want to
13654      call expand_expr to calculate the size of a variable-sized array.
13655      We haven't necessarily assigned RTL to all variables yet, so it's
13656      not safe to try to expand expressions involving them.  */
13657   immediate_size_expand = 0;
13658   cfun->x_dont_save_pending_sizes_p = 1;
13659
13660   /* If we're building a statement-tree, start the tree now.  */
13661   if (processing_template_decl || !expanding_p)
13662     begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13663
13664   /* Let the user know we're compiling this function.  */
13665   if (processing_template_decl || !building_stmt_tree ())
13666     announce_function (decl1);
13667
13668   /* Record the decl so that the function name is defined.
13669      If we already have a decl for this name, and it is a FUNCTION_DECL,
13670      use the old decl.  */
13671   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13672     {
13673       /* A specialization is not used to guide overload resolution.  */
13674       if (!DECL_TEMPLATE_SPECIALIZATION (decl1)
13675           && ! DECL_FUNCTION_MEMBER_P (decl1))
13676         decl1 = pushdecl (decl1);
13677       else
13678         {
13679           /* We need to set the DECL_CONTEXT. */
13680           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13681             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13682           /* And make sure we have enough default args.  */
13683           check_default_args (decl1);
13684         }
13685       fntype = TREE_TYPE (decl1);
13686     }
13687
13688   /* Reset these in case the call to pushdecl changed them.  */
13689   current_function_decl = decl1;
13690   cfun->decl = decl1;
13691
13692   /* Initialize the per-function data.  */
13693   if (!DECL_PENDING_INLINE_P (decl1) && DECL_SAVED_FUNCTION_DATA (decl1))
13694     {
13695       /* If we already parsed this function, and we're just expanding it
13696          now, restore saved state.  */
13697       struct binding_level *bl = current_binding_level;
13698       *cp_function_chain = *DECL_SAVED_FUNCTION_DATA (decl1);
13699       current_binding_level = bl;
13700
13701       /* This function is being processed in whole-function mode; we
13702          already did semantic analysis.  */
13703       cfun->x_whole_function_mode_p = 1;
13704
13705       /* If we decided that we didn't want to inline this function,
13706          make sure the back-end knows that.  */
13707       if (!current_function_cannot_inline)
13708         current_function_cannot_inline = cp_function_chain->cannot_inline;
13709
13710       /* We don't need the saved data anymore.  */
13711       free (DECL_SAVED_FUNCTION_DATA (decl1));
13712       DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13713     }
13714   else if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13715     {
13716       /* We know that this was set up by `grokclassfn'.  We do not
13717          wait until `store_parm_decls', since evil parse errors may
13718          never get us to that point.  Here we keep the consistency
13719          between `current_class_type' and `current_class_ptr'.  */
13720       tree t = DECL_ARGUMENTS (decl1);
13721
13722       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13723                           162);
13724       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13725                           19990811);
13726
13727       cp_function_chain->x_current_class_ref
13728         = build_indirect_ref (t, NULL_PTR);
13729       cp_function_chain->x_current_class_ptr = t;
13730
13731       /* Constructors and destructors need to know whether they're "in
13732          charge" of initializing virtual base classes.  */
13733       if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
13734         current_in_charge_parm = TREE_CHAIN (t);
13735     }
13736
13737   if (DECL_INTERFACE_KNOWN (decl1))
13738     {
13739       tree ctx = decl_function_context (decl1);
13740
13741       if (DECL_NOT_REALLY_EXTERN (decl1))
13742         DECL_EXTERNAL (decl1) = 0;
13743
13744       if (ctx != NULL_TREE && DECL_THIS_INLINE (ctx)
13745           && TREE_PUBLIC (ctx))
13746         /* This is a function in a local class in an extern inline
13747            function.  */
13748         comdat_linkage (decl1);
13749     }
13750   /* If this function belongs to an interface, it is public.
13751      If it belongs to someone else's interface, it is also external.
13752      This only affects inlines and template instantiations.  */
13753   else if (interface_unknown == 0
13754            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13755                || flag_alt_external_templates))
13756     {
13757       if (DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1)
13758           || processing_template_decl)
13759         {
13760           DECL_EXTERNAL (decl1)
13761             = (interface_only
13762                || (DECL_THIS_INLINE (decl1) && ! flag_implement_inlines
13763                    && !DECL_VINDEX (decl1)));
13764
13765           /* For WIN32 we also want to put these in linkonce sections.  */
13766           maybe_make_one_only (decl1);
13767         }
13768       else
13769         DECL_EXTERNAL (decl1) = 0;
13770       DECL_NOT_REALLY_EXTERN (decl1) = 0;
13771       DECL_INTERFACE_KNOWN (decl1) = 1;
13772     }
13773   else if (interface_unknown && interface_only
13774            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13775                || flag_alt_external_templates))
13776     {
13777       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13778          interface, we will have interface_only set but not
13779          interface_known.  In that case, we don't want to use the normal
13780          heuristics because someone will supply a #pragma implementation
13781          elsewhere, and deducing it here would produce a conflict.  */
13782       comdat_linkage (decl1);
13783       DECL_EXTERNAL (decl1) = 0;
13784       DECL_INTERFACE_KNOWN (decl1) = 1;
13785       DECL_DEFER_OUTPUT (decl1) = 1;
13786     }
13787   else
13788     {
13789       /* This is a definition, not a reference.
13790          So clear DECL_EXTERNAL.  */
13791       DECL_EXTERNAL (decl1) = 0;
13792
13793       if ((DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1))
13794           && ! DECL_INTERFACE_KNOWN (decl1)
13795           /* Don't try to defer nested functions for now.  */
13796           && ! decl_function_context (decl1))
13797         DECL_DEFER_OUTPUT (decl1) = 1;
13798       else
13799         DECL_INTERFACE_KNOWN (decl1) = 1;
13800     }
13801
13802   if (doing_semantic_analysis_p ())
13803     {
13804       pushlevel (0);
13805       current_binding_level->parm_flag = 1;
13806     }
13807
13808   if (attrs)
13809     cplus_decl_attributes (decl1, NULL_TREE, attrs);
13810
13811   if (!building_stmt_tree ())
13812     {
13813       GNU_xref_function (decl1, current_function_parms);
13814       make_function_rtl (decl1);
13815     }
13816
13817   /* Promote the value to int before returning it.  */
13818   if (C_PROMOTING_INTEGER_TYPE_P (restype))
13819     restype = type_promotes_to (restype);
13820
13821   /* If this fcn was already referenced via a block-scope `extern' decl
13822      (or an implicit decl), propagate certain information about the usage.  */
13823   if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1)))
13824     TREE_ADDRESSABLE (decl1) = 1;
13825
13826   if (DECL_RESULT (decl1) == NULL_TREE)
13827     {
13828       DECL_RESULT (decl1)
13829         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13830       TREE_READONLY (DECL_RESULT (decl1)) = CP_TYPE_CONST_P (restype);
13831       TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = CP_TYPE_VOLATILE_P (restype);
13832     }
13833
13834   ++function_depth;
13835
13836   if (DECL_DESTRUCTOR_P (decl1))
13837     {
13838       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13839       DECL_CONTEXT (dtor_label) = current_function_decl;
13840     }
13841   /* Under the old ABI we return `this' from constructors, so we make
13842      ordinary `return' statements in constructors jump to CTOR_LABEL;
13843      from there we return `this'.  Under the new ABI, we don't bother
13844      with any of this.  By not setting CTOR_LABEL the remainder of the
13845      machinery is automatically disabled.  */
13846   else if (!flag_new_abi && DECL_CONSTRUCTOR_P (decl1))
13847     {
13848       ctor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13849       DECL_CONTEXT (ctor_label) = current_function_decl;
13850     }
13851
13852   return 1;
13853 }
13854 \f
13855 /* Called after store_parm_decls for a function-try-block.  */
13856
13857 void
13858 expand_start_early_try_stmts ()
13859 {
13860   expand_start_try_stmts ();
13861 }
13862
13863 /* Store the parameter declarations into the current function declaration.
13864    This is called after parsing the parameter declarations, before
13865    digesting the body of the function.
13866
13867    Also install to binding contour return value identifier, if any.  */
13868
13869 void
13870 store_parm_decls ()
13871 {
13872   register tree fndecl = current_function_decl;
13873   register tree parm;
13874   int parms_have_cleanups = 0;
13875   tree cleanups = NULL_TREE;
13876
13877   /* This is a list of types declared among parms in a prototype.  */
13878   tree parmtags = current_function_parm_tags;
13879
13880   /* This is a chain of any other decls that came in among the parm
13881      declarations.  If a parm is declared with  enum {foo, bar} x;
13882      then CONST_DECLs for foo and bar are put here.  */
13883   tree nonparms = NULL_TREE;
13884
13885   /* Create a binding level for the parms.  */
13886   if (!building_stmt_tree ())
13887     expand_start_bindings (2);
13888
13889   if (current_function_parms)
13890     {
13891       /* This case is when the function was defined with an ANSI prototype.
13892          The parms already have decls, so we need not do anything here
13893          except record them as in effect
13894          and complain if any redundant old-style parm decls were written.  */
13895
13896       tree specparms = current_function_parms;
13897       tree next;
13898
13899       if (doing_semantic_analysis_p ())
13900         {
13901           /* Must clear this because it might contain TYPE_DECLs declared
13902              at class level.  */
13903           storedecls (NULL_TREE);
13904
13905           /* If we're doing semantic analysis, then we'll call pushdecl
13906              for each of these.  We must do them in reverse order so that
13907              they end in the correct forward order.  */
13908           specparms = nreverse (specparms);
13909         }
13910
13911       for (parm = specparms; parm; parm = next)
13912         {
13913           next = TREE_CHAIN (parm);
13914           if (TREE_CODE (parm) == PARM_DECL)
13915             {
13916               tree type = TREE_TYPE (parm);
13917
13918               if (doing_semantic_analysis_p ())
13919                 {
13920                   tree cleanup;
13921
13922                   if (DECL_NAME (parm) == NULL_TREE
13923                       || TREE_CODE (parm) != VOID_TYPE)
13924                     pushdecl (parm);
13925                   else
13926                     cp_error ("parameter `%D' declared void", parm);
13927
13928                   cleanup = (processing_template_decl
13929                              ? NULL_TREE
13930                              : maybe_build_cleanup (parm));
13931
13932                   if (cleanup)
13933                     cleanups = tree_cons (parm, cleanup, cleanups);
13934                 }
13935               else if (type != error_mark_node
13936                        && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
13937                 parms_have_cleanups = 1;
13938             }
13939           else
13940             {
13941               /* If we find an enum constant or a type tag,
13942                  put it aside for the moment.  */
13943               TREE_CHAIN (parm) = NULL_TREE;
13944               nonparms = chainon (nonparms, parm);
13945             }
13946         }
13947
13948       if (doing_semantic_analysis_p ())
13949         {
13950           /* Get the decls in their original chain order
13951              and record in the function.  This is all and only the
13952              PARM_DECLs that were pushed into scope by the loop above.  */
13953           DECL_ARGUMENTS (fndecl) = getdecls ();
13954           storetags (chainon (parmtags, gettags ()));
13955         }
13956     }
13957   else
13958     DECL_ARGUMENTS (fndecl) = NULL_TREE;
13959
13960   /* Now store the final chain of decls for the arguments
13961      as the decl-chain of the current lexical scope.
13962      Put the enumerators in as well, at the front so that
13963      DECL_ARGUMENTS is not modified.  */
13964   if (doing_semantic_analysis_p ())
13965     storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
13966
13967   /* Initialize the RTL code for the function.  */
13968   DECL_SAVED_INSNS (fndecl) = 0;
13969   if (! building_stmt_tree ())
13970     expand_function_start (fndecl, parms_have_cleanups);
13971
13972   current_function_parms_stored = 1;
13973
13974   /* If this function is `main', emit a call to `__main'
13975      to run global initializers, etc.  */
13976   if (DECL_MAIN_P (fndecl) && !building_stmt_tree ())
13977     expand_main_function ();
13978
13979   /* Now that we have initialized the parms, we can start their
13980      cleanups.  We cannot do this before, since expand_decl_cleanup
13981      should not be called before the parm can be used.  */
13982   while (cleanups)
13983     {
13984       finish_decl_cleanup (TREE_PURPOSE (cleanups),
13985                            TREE_VALUE (cleanups));
13986       cleanups = TREE_CHAIN (cleanups);
13987     }
13988
13989   /* Create a binding contour which can be used to catch
13990      cleanup-generated temporaries.  Also, if the return value needs or
13991      has initialization, deal with that now.  */
13992   if (parms_have_cleanups)
13993     {
13994       pushlevel (0);
13995       if (!building_stmt_tree ())
13996         expand_start_bindings (2);
13997     }
13998
13999   /* Do the starting of the exception specifications, if we have any.  */
14000   if (flag_exceptions && !processing_template_decl
14001       && flag_enforce_eh_specs
14002       && building_stmt_tree ()
14003       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14004     current_eh_spec_try_block = expand_start_eh_spec ();
14005 }
14006
14007 /* Bind a name and initialization to the return value of
14008    the current function.  */
14009
14010 void
14011 store_return_init (decl)
14012      tree decl;
14013 {
14014   /* If this named return value comes in a register, put it in a
14015      pseudo-register.  */
14016   if (DECL_REGISTER (decl))
14017     {
14018       original_result_rtx = DECL_RTL (decl);
14019       /* Note that the mode of the old DECL_RTL may be wider than the
14020          mode of DECL_RESULT, depending on the calling conventions for
14021          the processor.  For example, on the Alpha, a 32-bit integer
14022          is returned in a DImode register -- the DECL_RESULT has
14023          SImode but the DECL_RTL for the DECL_RESULT has DImode.  So,
14024          here, we use the mode the back-end has already assigned for
14025          the return value.  */
14026       DECL_RTL (decl) = gen_reg_rtx (GET_MODE (original_result_rtx));
14027       if (TREE_ADDRESSABLE (decl))
14028         put_var_into_stack (decl);
14029     }
14030 }
14031
14032 \f
14033 /* We have finished doing semantic analysis on DECL, but have not yet
14034    generated RTL for its body.  Save away our current state, so that
14035    when we want to generate RTL later we know what to do.  */
14036
14037 static void
14038 save_function_data (decl)
14039      tree decl;
14040 {
14041   struct language_function *f;
14042
14043   /* Save the language-specific per-function data so that we can
14044      get it back when we really expand this function.  */
14045   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
14046                       19990908);
14047
14048   /* Make a copy.  */
14049   f = ((struct language_function *)
14050        xmalloc (sizeof (struct language_function)));
14051   bcopy ((char *) cp_function_chain, (char *) f,
14052          sizeof (struct language_function));
14053   DECL_SAVED_FUNCTION_DATA (decl) = f;
14054
14055   /* Clear out the bits we don't need.  */
14056   f->x_base_init_list = NULL_TREE;
14057   f->x_member_init_list = NULL_TREE;
14058   f->x_stmt_tree.x_last_stmt = NULL_TREE;
14059   f->x_stmt_tree.x_last_expr_type = NULL_TREE;
14060   f->x_result_rtx = NULL_RTX;
14061   f->x_named_label_uses = NULL;
14062   f->bindings = NULL;
14063
14064   /* When we get back here again, we will be expanding.  */
14065   f->x_expanding_p = 1;
14066
14067   /* If we've already decided that we cannot inline this function, we
14068      must remember that fact when we actually go to expand the
14069      function.  */
14070   f->cannot_inline = current_function_cannot_inline;
14071 }
14072
14073 /* At the end of every constructor we generate to code to return
14074    `this'.  Do that now.  */
14075
14076 static void
14077 finish_constructor_body ()
14078 {
14079   /* Any return from a constructor will end up here.  */
14080   if (ctor_label)
14081     add_tree (build_min_nt (LABEL_STMT, ctor_label));
14082
14083   /* Clear CTOR_LABEL so that finish_return_stmt knows to really
14084      generate the return, rather than a goto to CTOR_LABEL.  */
14085   ctor_label = NULL_TREE;
14086   /* In check_return_expr we translate an empty return from a
14087      constructor to a return of `this'.  */
14088   finish_return_stmt (NULL_TREE);
14089   /* Mark the end of the constructor.  */
14090   add_tree (build_min_nt (CTOR_STMT));
14091 }
14092
14093 /* At the end of every destructor we generate code to restore virtual
14094    function tables to the values desired by base classes and to call
14095    to base class destructors.  Do that now.  */
14096
14097 static void
14098 finish_destructor_body ()
14099 {
14100   tree compound_stmt;
14101   tree virtual_size;
14102   tree exprstmt;
14103   tree if_stmt;
14104
14105   /* Create a block to contain all the extra code.  */
14106   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
14107
14108   /* Any return from a destructor will end up here.  */
14109   add_tree (build_min_nt (LABEL_STMT, dtor_label));
14110
14111   /* Generate the code to call destructor on base class.  If this
14112      destructor belongs to a class with virtual functions, then set
14113      the virtual function table pointer to represent the type of our
14114      base class.  */
14115
14116   /* This side-effect makes call to `build_delete' generate the code
14117      we have to have at the end of this destructor.  `build_delete'
14118      will set the flag again.  */
14119   TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
14120
14121   exprstmt = build_delete (current_class_type,
14122                            current_class_ref,
14123                            sfk_base_destructor,
14124                            LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
14125                            0);
14126
14127   if (exprstmt != error_mark_node
14128       && (TREE_CODE (exprstmt) != NOP_EXPR
14129           || TREE_OPERAND (exprstmt, 0) != integer_zero_node
14130           || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
14131     {
14132       if (exprstmt != void_zero_node)
14133         /* Don't call `expand_expr_stmt' if we're not going to do
14134            anything, since -Wall will give a diagnostic.  */
14135         finish_expr_stmt (exprstmt);
14136
14137       /* Run destructors for all virtual baseclasses.  */
14138       if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
14139         {
14140           tree vbases;
14141           tree if_stmt;
14142
14143           if_stmt = begin_if_stmt ();
14144           finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
14145                                       current_in_charge_parm,
14146                                       integer_two_node),
14147                                if_stmt);
14148
14149           vbases = CLASSTYPE_VBASECLASSES (current_class_type);
14150           /* The CLASSTYPE_VBASECLASSES list is in initialization
14151              order, so we have to march through it in reverse order.  */
14152           for (vbases = nreverse (copy_list (vbases));
14153                vbases;
14154                vbases = TREE_CHAIN (vbases))
14155             {
14156               tree vbase = TREE_VALUE (vbases);
14157
14158               if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (vbase)))
14159                 {
14160                   tree vb = get_vbase
14161                     (BINFO_TYPE (vbase),
14162                      TYPE_BINFO (current_class_type));
14163                   finish_expr_stmt
14164                     (build_scoped_method_call
14165                      (current_class_ref, vb, base_dtor_identifier,
14166                       NULL_TREE));
14167                 }
14168             }
14169
14170           finish_then_clause (if_stmt);
14171           finish_if_stmt ();
14172         }
14173     }
14174
14175   virtual_size = c_sizeof (current_class_type);
14176
14177   /* At the end, call delete if that's what's requested.  */
14178
14179   /* FDIS sez: At the point of definition of a virtual destructor
14180      (including an implicit definition), non-placement operator delete
14181      shall be looked up in the scope of the destructor's class and if
14182      found shall be accessible and unambiguous.
14183
14184      This is somewhat unclear, but I take it to mean that if the class
14185      only defines placement deletes we don't do anything here.  So we
14186      pass LOOKUP_SPECULATIVELY; delete_sanity will complain for us if
14187      they ever try to delete one of these.  */
14188   exprstmt = build_op_delete_call
14189     (DELETE_EXPR, current_class_ptr, virtual_size,
14190      LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
14191
14192   if_stmt = begin_if_stmt ();
14193   finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
14194                               current_in_charge_parm,
14195                               integer_one_node),
14196                        if_stmt);
14197   finish_expr_stmt (exprstmt);
14198   finish_then_clause (if_stmt);
14199   finish_if_stmt ();
14200
14201   /* Close the block we started above.  */
14202   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
14203 }
14204
14205 /* Finish up a function declaration and compile that function
14206    all the way to assembler language output.  The free the storage
14207    for the function definition.
14208
14209    FLAGS is a bitwise or of the following values:
14210      1 - CALL_POPLEVEL
14211        An extra call to poplevel (and expand_end_bindings) must be
14212        made to take care of the binding contour for the base
14213        initializers.  This is only relevant for constructors.
14214      2 - INCLASS_INLINE
14215        We just finished processing the body of an in-class inline
14216        function definition.  (This processing will have taken place
14217        after the class definition is complete.)  */
14218
14219 tree
14220 finish_function (flags)
14221      int flags;
14222 {
14223   register tree fndecl = current_function_decl;
14224   tree fntype, ctype = NULL_TREE;
14225   /* Label to use if this function is supposed to return a value.  */
14226   tree no_return_label = NULL_TREE;
14227   int call_poplevel = (flags & 1) != 0;
14228   int inclass_inline = (flags & 2) != 0;
14229   int expand_p;
14230   int nested;
14231   int current_line = lineno;
14232
14233   /* When we get some parse errors, we can end up without a
14234      current_function_decl, so cope.  */
14235   if (fndecl == NULL_TREE)
14236     return error_mark_node;
14237
14238   nested = function_depth > 1;
14239   fntype = TREE_TYPE (fndecl);
14240
14241   /*  TREE_READONLY (fndecl) = 1;
14242       This caused &foo to be of type ptr-to-const-function
14243       which then got a warning when stored in a ptr-to-function variable.  */
14244
14245   /* This happens on strange parse errors.  */
14246   if (! current_function_parms_stored)
14247     {
14248       call_poplevel = 0;
14249       store_parm_decls ();
14250     }
14251
14252   /* For a cloned function, we've already got all the code we need;
14253      there's no need to add any extra bits.  */
14254   if (building_stmt_tree () && DECL_CLONED_FUNCTION_P (fndecl))
14255     ;
14256   else if (building_stmt_tree ())
14257     {
14258       if (DECL_CONSTRUCTOR_P (fndecl))
14259         {
14260           finish_constructor_body ();
14261           if (call_poplevel)
14262             do_poplevel ();
14263         }
14264       else if (DECL_DESTRUCTOR_P (fndecl) && !processing_template_decl)
14265         finish_destructor_body ();
14266       else if (DECL_MAIN_P (fndecl))
14267         {
14268           /* Make it so that `main' always returns 0 by default.  */
14269 #ifdef VMS
14270           finish_return_stmt (integer_one_node);
14271 #else
14272           finish_return_stmt (integer_zero_node);
14273 #endif
14274         }
14275
14276       /* Finish dealing with exception specifiers.  */
14277       if (flag_exceptions && !processing_template_decl
14278           && flag_enforce_eh_specs
14279           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14280         expand_end_eh_spec (TYPE_RAISES_EXCEPTIONS
14281                             (TREE_TYPE (current_function_decl)),
14282                             current_eh_spec_try_block);
14283     }
14284   else
14285     {
14286 #if 0
14287       if (write_symbols != NO_DEBUG /*&& TREE_CODE (fntype) != METHOD_TYPE*/)
14288         {
14289           /* Keep this code around in case we later want to control debug info
14290              based on whether a type is "used".  (jason 1999-11-11) */
14291
14292           tree ttype = target_type (fntype);
14293           tree parmdecl;
14294
14295           if (IS_AGGR_TYPE (ttype))
14296             /* Let debugger know it should output info for this type.  */
14297             note_debug_info_needed (ttype);
14298
14299           for (parmdecl = DECL_ARGUMENTS (fndecl); parmdecl; parmdecl = TREE_CHAIN (parmdecl))
14300             {
14301               ttype = target_type (TREE_TYPE (parmdecl));
14302               if (IS_AGGR_TYPE (ttype))
14303                 /* Let debugger know it should output info for this type.  */
14304                 note_debug_info_needed (ttype);
14305             }
14306         }
14307 #endif
14308
14309       /* Clean house because we will need to reorder insns here.  */
14310       do_pending_stack_adjust ();
14311
14312       if (dtor_label)
14313         ;
14314       else if (DECL_CONSTRUCTOR_P (fndecl))
14315         {
14316           if (call_poplevel)
14317             do_poplevel ();
14318         }
14319       else if (return_label != NULL_RTX
14320                && flag_this_is_variable <= 0
14321                && current_function_return_value == NULL_TREE
14322                && ! DECL_NAME (DECL_RESULT (current_function_decl)))
14323         no_return_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
14324
14325       if (flag_exceptions)
14326         expand_exception_blocks ();
14327
14328       /* If this function is supposed to return a value, ensure that
14329          we do not fall into the cleanups by mistake.  The end of our
14330          function will look like this:
14331
14332          user code (may have return stmt somewhere)
14333          goto no_return_label
14334          cleanup_label:
14335          cleanups
14336          goto return_label
14337          no_return_label:
14338          NOTE_INSN_FUNCTION_END
14339          return_label:
14340          things for return
14341
14342          If the user omits a return stmt in the USER CODE section, we
14343          will have a control path which reaches NOTE_INSN_FUNCTION_END.
14344          Otherwise, we won't.  */
14345       if (no_return_label)
14346         {
14347           DECL_CONTEXT (no_return_label) = fndecl;
14348           DECL_INITIAL (no_return_label) = error_mark_node;
14349           DECL_SOURCE_FILE (no_return_label) = input_filename;
14350           DECL_SOURCE_LINE (no_return_label) = current_line;
14351           expand_goto (no_return_label);
14352         }
14353
14354       if (cleanup_label)
14355         {
14356           /* Remove the binding contour which is used
14357              to catch cleanup-generated temporaries.  */
14358           expand_end_bindings (0, 0, 0);
14359           poplevel (0, 0, 0);
14360
14361           /* Emit label at beginning of cleanup code for parameters.  */
14362           emit_label (cleanup_label);
14363         }
14364
14365       /* Get return value into register if that's where it's supposed
14366          to be.  */
14367       if (original_result_rtx)
14368         fixup_result_decl (DECL_RESULT (fndecl), original_result_rtx);
14369
14370       /* Finish building code that will trigger warnings if users forget
14371          to make their functions return values.  */
14372       if (no_return_label || cleanup_label)
14373         emit_jump (return_label);
14374       if (no_return_label)
14375         {
14376           /* We don't need to call `expand_*_return' here because we
14377              don't need any cleanups here--this path of code is only
14378              for error checking purposes.  */
14379           expand_label (no_return_label);
14380         }
14381
14382       /* We hard-wired immediate_size_expand to zero in
14383          start_function.  Expand_function_end will decrement this
14384          variable.  So, we set the variable to one here, so that after
14385          the decrement it will remain zero.  */
14386       immediate_size_expand = 1;
14387
14388       /* Generate rtl for function exit.  */
14389       expand_function_end (input_filename, current_line, 1);
14390     }
14391
14392   /* We have to save this value here in case
14393      maybe_end_member_template_processing decides to pop all the
14394      template parameters.  */
14395   expand_p = !building_stmt_tree ();
14396
14397   /* If we're saving up tree structure, tie off the function now.  */
14398   if (!expand_p)
14399     finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
14400
14401   /* This must come after expand_function_end because cleanups might
14402      have declarations (from inline functions) that need to go into
14403      this function's blocks.  */
14404   if (doing_semantic_analysis_p ())
14405     {
14406       if (current_binding_level->parm_flag != 1)
14407         my_friendly_abort (122);
14408       poplevel (1, 0, 1);
14409     }
14410
14411   /* Remember that we were in class scope.  */
14412   if (current_class_name)
14413     ctype = current_class_type;
14414
14415   /* Must mark the RESULT_DECL as being in this function.  */
14416   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
14417
14418   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14419      to the FUNCTION_DECL node itself.  */
14420   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
14421
14422   /* Save away current state, if appropriate.  */
14423   if (!expanding_p && !processing_template_decl)
14424     save_function_data (fndecl);
14425
14426   /* If this function calls `setjmp' it cannot be inlined.  When
14427      `longjmp' is called it is not guaranteed to restore the value of
14428      local variables that have been modified since the call to
14429      `setjmp'.  So, if were to inline this function into some caller
14430      `c', then when we `longjmp', we might not restore all variables
14431      in `c'.  (It might seem, at first blush, that there's no way for
14432      this function to modify local variables in `c', but their
14433      addresses may have been stored somewhere accessible to this
14434      function.)  */
14435   if (!expanding_p && !processing_template_decl && calls_setjmp_p (fndecl))
14436     DECL_UNINLINABLE (fndecl) = 1;
14437
14438   if (expand_p)
14439     {
14440       int returns_null;
14441       int returns_value;
14442
14443       /* So we can tell if jump_optimize sets it to 1.  */
14444       can_reach_end = 0;
14445
14446       /* Before we call rest_of_compilation (which will pop the
14447          CURRENT_FUNCTION), we must save these values.  */
14448       returns_null = current_function_returns_null;
14449       returns_value = current_function_returns_value;
14450
14451       /* If this is a nested function (like a template instantiation
14452          that we're compiling in the midst of compiling something
14453          else), push a new GC context.  That will keep local variables
14454          on the stack from being collected while we're doing the
14455          compilation of this function.  */
14456       if (function_depth > 1)
14457         ggc_push_context ();
14458
14459       /* Run the optimizers and output the assembler code for this
14460          function.  */
14461       rest_of_compilation (fndecl);
14462
14463       /* Undo the call to ggc_push_context above.  */
14464       if (function_depth > 1)
14465         ggc_pop_context ();
14466
14467       if (DECL_SAVED_INSNS (fndecl) && ! TREE_ASM_WRITTEN (fndecl))
14468         {
14469           /* Set DECL_EXTERNAL so that assemble_external will be called as
14470              necessary.  We'll clear it again in finish_file.  */
14471           if (! DECL_EXTERNAL (fndecl))
14472             DECL_NOT_REALLY_EXTERN (fndecl) = 1;
14473           DECL_EXTERNAL (fndecl) = 1;
14474           defer_fn (fndecl);
14475         }
14476
14477 #if 0
14478       /* Keep this code around in case we later want to control debug info
14479          based on whether a type is "used".  (jason 1999-11-11) */
14480
14481       if (ctype && TREE_ASM_WRITTEN (fndecl))
14482         note_debug_info_needed (ctype);
14483 #endif
14484
14485       returns_null |= can_reach_end;
14486
14487       /* Since we don't normally go through c_expand_return for constructors,
14488          this normally gets the wrong value.
14489          Also, named return values have their return codes emitted after
14490          NOTE_INSN_FUNCTION_END, confusing jump.c.  */
14491       if (DECL_CONSTRUCTOR_P (fndecl)
14492           || DECL_NAME (DECL_RESULT (fndecl)) != NULL_TREE)
14493         returns_null = 0;
14494
14495       if (TREE_THIS_VOLATILE (fndecl) && returns_null)
14496         cp_warning ("`noreturn' function `%D' does return", fndecl);
14497       else if ((warn_return_type || pedantic)
14498                && returns_null
14499                && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE)
14500         {
14501           /* If this function returns non-void and control can drop through,
14502              complain.  */
14503           cp_warning ("control reaches end of non-void function `%D'", fndecl);
14504         }
14505       /* With just -W, complain only if function returns both with
14506          and without a value.  */
14507       else if (extra_warnings && returns_value && returns_null)
14508         warning ("this function may return with or without a value");
14509     }
14510   else
14511     {
14512       /* Clear out memory we no longer need.  */
14513       free_after_parsing (cfun);
14514       /* Since we never call rest_of_compilation, we never clear
14515          CFUN.  Do so explicitly.  */
14516       free_after_compilation (cfun);
14517       cfun = NULL;
14518     }
14519
14520   /* If this is a in-class inline definition, we may have to pop the
14521      bindings for the template parameters that we added in
14522      maybe_begin_member_template_processing when start_function was
14523      called.  */
14524   if (inclass_inline)
14525     maybe_end_member_template_processing ();
14526
14527   /* Leave the scope of the class.  */
14528   if (ctype)
14529     pop_nested_class ();
14530
14531   --function_depth;
14532
14533   if (!DECL_SAVED_INSNS (fndecl) && !DECL_SAVED_FUNCTION_DATA (fndecl)
14534       && !(flag_inline_trees && DECL_INLINE (fndecl)))
14535     {
14536       tree t;
14537
14538       /* Stop pointing to the local nodes about to be freed.  */
14539       /* But DECL_INITIAL must remain nonzero so we know this
14540          was an actual function definition.  */
14541       DECL_INITIAL (fndecl) = error_mark_node;
14542       for (t = DECL_ARGUMENTS (fndecl); t; t = TREE_CHAIN (t))
14543         DECL_RTL (t) = DECL_INCOMING_RTL (t) = NULL_RTX;
14544     }
14545
14546   if (DECL_STATIC_CONSTRUCTOR (fndecl))
14547     static_ctors = tree_cons (NULL_TREE, fndecl, static_ctors);
14548   if (DECL_STATIC_DESTRUCTOR (fndecl))
14549     static_dtors = tree_cons (NULL_TREE, fndecl, static_dtors);
14550
14551   /* Clean up.  */
14552   if (! nested)
14553     {
14554       /* Let the error reporting routines know that we're outside a
14555          function.  For a nested function, this value is used in
14556          pop_cp_function_context and then reset via pop_function_context.  */
14557       current_function_decl = NULL_TREE;
14558       /* We don't really care about obstacks, but the middle-end
14559          sometimes cares on what obstck things are located.  */
14560       permanent_allocation (1);
14561     }
14562
14563   return fndecl;
14564 }
14565 \f
14566 /* Create the FUNCTION_DECL for a function definition.
14567    DECLSPECS and DECLARATOR are the parts of the declaration;
14568    they describe the return type and the name of the function,
14569    but twisted together in a fashion that parallels the syntax of C.
14570
14571    This function creates a binding context for the function body
14572    as well as setting up the FUNCTION_DECL in current_function_decl.
14573
14574    Returns a FUNCTION_DECL on success.
14575
14576    If the DECLARATOR is not suitable for a function (it defines a datum
14577    instead), we return 0, which tells yyparse to report a parse error.
14578
14579    May return void_type_node indicating that this method is actually
14580    a friend.  See grokfield for more details.
14581
14582    Came here with a `.pushlevel' .
14583
14584    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14585    CHANGES TO CODE IN `grokfield'.  */
14586
14587 tree
14588 start_method (declspecs, declarator, attrlist)
14589      tree declarator, declspecs, attrlist;
14590 {
14591   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14592                                 attrlist);
14593
14594   /* Something too ugly to handle.  */
14595   if (fndecl == NULL_TREE)
14596     return NULL_TREE;
14597
14598   /* Pass friends other than inline friend functions back.  */
14599   if (fndecl == void_type_node)
14600     return fndecl;
14601
14602   if (TREE_CODE (fndecl) != FUNCTION_DECL)
14603     /* Not a function, tell parser to report parse error.  */
14604     return NULL_TREE;
14605
14606   if (DECL_IN_AGGR_P (fndecl))
14607     {
14608       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14609         {
14610           if (DECL_CONTEXT (fndecl)
14611               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14612             cp_error ("`%D' is already defined in class %s", fndecl,
14613                              TYPE_NAME_STRING (DECL_CONTEXT (fndecl)));
14614         }
14615       return void_type_node;
14616     }
14617
14618   check_template_shadow (fndecl);
14619
14620   DECL_THIS_INLINE (fndecl) = 1;
14621
14622   if (flag_default_inline)
14623     DECL_INLINE (fndecl) = 1;
14624
14625   /* We process method specializations in finish_struct_1.  */
14626   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14627     fndecl = push_template_decl (fndecl);
14628
14629   if (! DECL_FRIEND_P (fndecl))
14630     {
14631       if (TREE_CHAIN (fndecl))
14632         {
14633           fndecl = copy_node (fndecl);
14634           TREE_CHAIN (fndecl) = NULL_TREE;
14635         }
14636
14637       if (DECL_CONSTRUCTOR_P (fndecl))
14638         {
14639           if (! grok_ctor_properties (current_class_type, fndecl))
14640             return void_type_node;
14641         }
14642       else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl)))
14643         grok_op_properties (fndecl, DECL_VIRTUAL_P (fndecl), 0);
14644     }
14645
14646   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14647
14648   /* Make a place for the parms */
14649   pushlevel (0);
14650   current_binding_level->parm_flag = 1;
14651
14652   DECL_IN_AGGR_P (fndecl) = 1;
14653   return fndecl;
14654 }
14655
14656 /* Go through the motions of finishing a function definition.
14657    We don't compile this method until after the whole class has
14658    been processed.
14659
14660    FINISH_METHOD must return something that looks as though it
14661    came from GROKFIELD (since we are defining a method, after all).
14662
14663    This is called after parsing the body of the function definition.
14664    STMTS is the chain of statements that makes up the function body.
14665
14666    DECL is the ..._DECL that `start_method' provided.  */
14667
14668 tree
14669 finish_method (decl)
14670      tree decl;
14671 {
14672   register tree fndecl = decl;
14673   tree old_initial;
14674
14675   register tree link;
14676
14677   if (decl == void_type_node)
14678     return decl;
14679
14680   old_initial = DECL_INITIAL (fndecl);
14681
14682   /* Undo the level for the parms (from start_method).
14683      This is like poplevel, but it causes nothing to be
14684      saved.  Saving information here confuses symbol-table
14685      output routines.  Besides, this information will
14686      be correctly output when this method is actually
14687      compiled.  */
14688
14689   /* Clear out the meanings of the local variables of this level;
14690      also record in each decl which block it belongs to.  */
14691
14692   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14693     {
14694       if (DECL_NAME (link) != NULL_TREE)
14695         pop_binding (DECL_NAME (link), link);
14696       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14697       DECL_CONTEXT (link) = NULL_TREE;
14698     }
14699
14700   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
14701                       (HOST_WIDE_INT) current_binding_level->level_chain,
14702                       current_binding_level->parm_flag,
14703                       current_binding_level->keep);
14704
14705   poplevel (0, 0, 0);
14706
14707   DECL_INITIAL (fndecl) = old_initial;
14708
14709   /* We used to check if the context of FNDECL was different from
14710      current_class_type as another way to get inside here.  This didn't work
14711      for String.cc in libg++.  */
14712   if (DECL_FRIEND_P (fndecl))
14713     {
14714       CLASSTYPE_INLINE_FRIENDS (current_class_type)
14715         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14716       decl = void_type_node;
14717     }
14718
14719   return decl;
14720 }
14721 \f
14722 /* Called when a new struct TYPE is defined.
14723    If this structure or union completes the type of any previous
14724    variable declaration, lay it out and output its rtl.  */
14725
14726 void
14727 hack_incomplete_structures (type)
14728      tree type;
14729 {
14730   tree *list;
14731   struct binding_level *level;
14732
14733   if (!type) /* Don't do this for class templates.  */
14734     return;
14735
14736   if (namespace_bindings_p ())
14737     {
14738       level = 0;
14739       list = &namespace_scope_incomplete;
14740     }
14741   else
14742     {
14743       level = innermost_nonclass_level ();
14744       list = &level->incomplete;
14745     }
14746
14747   while (1)
14748     {
14749       while (*list)
14750         {
14751           tree decl = TREE_VALUE (*list);
14752           if ((decl && TREE_TYPE (decl) == type)
14753               || (TREE_TYPE (decl)
14754                   && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14755                   && TREE_TYPE (TREE_TYPE (decl)) == type))
14756             {
14757               int toplevel = toplevel_bindings_p ();
14758               if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14759                   && TREE_TYPE (TREE_TYPE (decl)) == type)
14760                 layout_type (TREE_TYPE (decl));
14761               layout_decl (decl, 0);
14762               rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
14763               if (! toplevel)
14764                 {
14765                   tree cleanup;
14766                   expand_decl (decl);
14767                   cleanup = maybe_build_cleanup (decl);
14768                   expand_decl_init (decl);
14769                   if (! expand_decl_cleanup (decl, cleanup))
14770                     cp_error ("parser lost in parsing declaration of `%D'",
14771                               decl);
14772                 }
14773               *list = TREE_CHAIN (*list);
14774             }
14775           else
14776             list = &TREE_CHAIN (*list);
14777         }
14778
14779       /* Keep looking through artificial binding levels generated
14780          for local variables.  */
14781       if (level && level->keep == 2)
14782         {
14783           level = level->level_chain;
14784           list = &level->incomplete;
14785         }
14786       else
14787         break;
14788     }
14789 }
14790
14791 /* If DECL is of a type which needs a cleanup, build that cleanup
14792    here.  */
14793
14794 tree
14795 maybe_build_cleanup (decl)
14796      tree decl;
14797 {
14798   tree type = TREE_TYPE (decl);
14799
14800   if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14801     {
14802       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14803       tree rval;
14804
14805       if (TREE_CODE (type) == ARRAY_TYPE)
14806         rval = decl;
14807       else
14808         {
14809           mark_addressable (decl);
14810           rval = build_unary_op (ADDR_EXPR, decl, 0);
14811         }
14812
14813       /* Optimize for space over speed here.  */
14814       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14815           || flag_expensive_optimizations)
14816         flags |= LOOKUP_NONVIRTUAL;
14817
14818       rval = build_delete (TREE_TYPE (rval), rval,
14819                            sfk_complete_destructor, flags, 0);
14820
14821       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14822           && ! TYPE_HAS_DESTRUCTOR (type))
14823         rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14824                                                build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14825
14826       return rval;
14827     }
14828   return 0;
14829 }
14830 \f
14831 /* Expand a C++ expression at the statement level.
14832    This is needed to ferret out nodes which have UNKNOWN_TYPE.
14833    The C++ type checker should get all of these out when
14834    expressions are combined with other, type-providing, expressions,
14835    leaving only orphan expressions, such as:
14836
14837    &class::bar;         / / takes its address, but does nothing with it.  */
14838
14839 void
14840 cplus_expand_expr_stmt (exp)
14841      tree exp;
14842 {
14843 #if 0
14844   /* We should do this eventually, but right now this causes regex.o from
14845      libg++ to miscompile, and tString to core dump.  */
14846   exp = build1 (CLEANUP_POINT_EXPR, TREE_TYPE (exp), exp);
14847 #endif
14848
14849   /* If we don't do this, we end up down inside expand_expr
14850      trying to do TYPE_MODE on the ERROR_MARK, and really
14851      go outside the bounds of the type.  */
14852   if (exp != error_mark_node)
14853     expand_expr_stmt (exp);
14854 }
14855
14856 /* When a stmt has been parsed, this function is called.  */
14857
14858 void
14859 finish_stmt ()
14860 {
14861   /* Always assume this statement was not an expression statement.  If
14862      it actually was an expression statement, its our callers
14863      responsibility to fix this up.  */
14864   last_expr_type = NULL_TREE;
14865 }
14866
14867 /* DECL was originally constructed as a non-static member function,
14868    but turned out to be static.  Update it accordingly.  */
14869
14870 void
14871 revert_static_member_fn (decl)
14872      tree decl;
14873 {
14874   tree tmp;
14875   tree function = TREE_TYPE (decl);
14876   tree args = TYPE_ARG_TYPES (function);
14877
14878   if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args)))
14879       != TYPE_UNQUALIFIED)
14880     cp_error ("static member function `%#D' declared with type qualifiers",
14881               *decl);
14882
14883   args = TREE_CHAIN (args);
14884   tmp = build_function_type (TREE_TYPE (function), args);
14885   tmp = build_qualified_type (tmp, CP_TYPE_QUALS (function));
14886   tmp = build_exception_variant (tmp,
14887                                  TYPE_RAISES_EXCEPTIONS (function));
14888   TREE_TYPE (decl) = tmp;
14889   if (DECL_ARGUMENTS (decl))
14890     DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
14891   DECL_STATIC_FUNCTION_P (decl) = 1;
14892 }
14893
14894 /* Initialize the variables used during compilation of a C++
14895    function.  */
14896
14897 static void
14898 push_cp_function_context (f)
14899      struct function *f;
14900 {
14901   struct language_function *p
14902     = ((struct language_function *)
14903        xcalloc (1, sizeof (struct language_function)));
14904   f->language = p;
14905
14906   /* It takes an explicit call to expand_body to generate RTL for a
14907      function.  */
14908   expanding_p = 0;
14909
14910   /* Whenever we start a new function, we destroy temporaries in the
14911      usual way.  */
14912   stmts_are_full_exprs_p = 1;
14913 }
14914
14915 /* Free the language-specific parts of F, now that we've finished
14916    compiling the function.  */
14917
14918 static void
14919 pop_cp_function_context (f)
14920      struct function *f;
14921 {
14922   if (f->language)
14923     free (f->language);
14924   f->language = 0;
14925 }
14926
14927 /* Mark P for GC.  */
14928
14929 static void
14930 mark_lang_function (p)
14931      struct language_function *p;
14932 {
14933   if (!p)
14934     return;
14935
14936   ggc_mark_tree (p->x_ctor_label);
14937   ggc_mark_tree (p->x_dtor_label);
14938   ggc_mark_tree (p->x_base_init_list);
14939   ggc_mark_tree (p->x_member_init_list);
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           ggc_mark_tree (ld->decl_flags.context);
15014           if (TREE_CODE (t) != NAMESPACE_DECL)
15015             ggc_mark_tree (ld->decl_flags.u.template_info);
15016           else
15017             mark_binding_level (&NAMESPACE_LEVEL (t));
15018           if (CAN_HAVE_FULL_LANG_DECL_P (t))
15019             {
15020               ggc_mark_tree (ld->befriending_classes);
15021               ggc_mark_tree (ld->saved_tree);
15022               ggc_mark_tree (ld->cloned_function);
15023               if (!DECL_OVERLOADED_OPERATOR_P (t))
15024                 ggc_mark_tree (ld->u2.vtt_parm);
15025               if (TREE_CODE (t) == TYPE_DECL)
15026                 ggc_mark_tree (ld->u.sorted_fields);
15027               else if (TREE_CODE (t) == FUNCTION_DECL
15028                        && !DECL_PENDING_INLINE_P (t))
15029                 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t));
15030             }
15031         }
15032     }
15033   else if (TREE_CODE_CLASS (code) == 't')
15034     {
15035       struct lang_type *lt = TYPE_LANG_SPECIFIC (t);
15036
15037       if (lt && !(TREE_CODE (t) == POINTER_TYPE
15038                   && TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE))
15039         {
15040           ggc_mark (lt);
15041           ggc_mark_tree (lt->vfields);
15042           ggc_mark_tree (lt->vbases);
15043           ggc_mark_tree (lt->tags);
15044           ggc_mark_tree (lt->size);
15045           ggc_mark_tree (lt->pure_virtuals);
15046           ggc_mark_tree (lt->friend_classes);
15047           ggc_mark_tree (lt->rtti);
15048           ggc_mark_tree (lt->methods);
15049           ggc_mark_tree (lt->template_info);
15050           ggc_mark_tree (lt->befriending_classes);
15051         }
15052       else if (lt)
15053         /* In the case of pointer-to-member function types, the
15054            TYPE_LANG_SPECIFIC is really just a tree.  */
15055         ggc_mark_tree ((tree) lt);
15056     }
15057 }