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