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 "defaults.h"
  41 #include "output.h"
  42 #include "except.h"
  43 #include "toplev.h"
  44 #include "../hash.h"
  45 #include "defaults.h"
  46 #include "ggc.h"
  47
  48 extern int current_class_depth;
  49
  50 extern tree static_ctors, static_dtors;
  51
  52 extern tree global_namespace;
  53
  54 extern int (*valid_lang_attribute) PARAMS ((tree, tree, tree, tree));
  55
  56 /* Use garbage collection.  */
  57
  58 int ggc_p = 1;
  59
  60 #ifndef WCHAR_UNSIGNED
  61 #define WCHAR_UNSIGNED 0
  62 #endif
  63
  64 #ifndef CHAR_TYPE_SIZE
  65 #define CHAR_TYPE_SIZE BITS_PER_UNIT
  66 #endif
  67
  68 #ifndef BOOL_TYPE_SIZE
  69 #ifdef SLOW_BYTE_ACCESS
  70 /* In the new ABI, `bool' has size and alignment `1', on all
  71    platforms.  */
  72 #define BOOL_TYPE_SIZE \
  73   ((SLOW_BYTE_ACCESS && !flag_new_abi) ? (POINTER_SIZE) : (CHAR_TYPE_SIZE))
  74 #else
  75 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
  76 #endif
  77 #endif
  78
  79 /* We let tm.h override the types used here, to handle trivial differences
  80    such as the choice of unsigned int or long unsigned int for size_t.
  81    When machines start needing nontrivial differences in the size type,
  82    it would be best to do something here to figure out automatically
  83    from other information what type to use.  */
  84
  85 #ifndef SIZE_TYPE
  86 #define SIZE_TYPE "long unsigned int"
  87 #endif
  88
  89 #ifndef PTRDIFF_TYPE
  90 #define PTRDIFF_TYPE "long int"
  91 #endif
  92
  93 #ifndef WCHAR_TYPE
  94 #define WCHAR_TYPE "int"
  95 #endif
  96
  97 static tree grokparms                           PARAMS ((tree, int));
  98 static const char *redeclaration_error_message  PARAMS ((tree, tree));
  99
 100 static void push_binding_level PARAMS ((struct binding_level *, int,
 101                                       int));
 102 static void pop_binding_level PARAMS ((void));
 103 static void suspend_binding_level PARAMS ((void));
 104 static void resume_binding_level PARAMS ((struct binding_level *));
 105 static struct binding_level *make_binding_level PARAMS ((void));
 106 static void declare_namespace_level PARAMS ((void));
 107 static int decl_jump_unsafe PARAMS ((tree));
 108 static void storedecls PARAMS ((tree));
 109 static void require_complete_types_for_parms PARAMS ((tree));
 110 static int ambi_op_p PARAMS ((enum tree_code));
 111 static int unary_op_p PARAMS ((enum tree_code));
 112 static tree store_bindings PARAMS ((tree, tree));
 113 static tree lookup_tag_reverse PARAMS ((tree, tree));
 114 static tree obscure_complex_init PARAMS ((tree, tree));
 115 static tree lookup_name_real PARAMS ((tree, int, int, int));
 116 static void warn_extern_redeclared_static PARAMS ((tree, tree));
 117 static void grok_reference_init PARAMS ((tree, tree, tree));
 118 static tree grokfndecl PARAMS ((tree, tree, tree, tree, int,
 119                               enum overload_flags, tree,
 120                               tree, int, int, int, int, int, int, tree));
 121 static tree grokvardecl PARAMS ((tree, tree, RID_BIT_TYPE *, int, int, tree));
 122 static tree lookup_tag PARAMS ((enum tree_code, tree,
 123                               struct binding_level *, int));
 124 static void set_identifier_type_value_with_scope
 125         PARAMS ((tree, tree, struct binding_level *));
 126 static void record_builtin_type PARAMS ((enum rid, const char *, tree));
 127 static void record_unknown_type PARAMS ((tree, const char *));
 128 static tree build_library_fn_1 PARAMS ((tree, enum tree_code, tree));
 129 static int member_function_or_else PARAMS ((tree, tree, enum overload_flags));
 130 static void bad_specifiers PARAMS ((tree, const char *, int, int, int, int,
 131                                   int));
 132 static void lang_print_error_function PARAMS ((const char *));
 133 static tree maybe_process_template_type_declaration PARAMS ((tree, int, struct binding_level*));
 134 static void check_for_uninitialized_const_var PARAMS ((tree));
 135 static unsigned long typename_hash PARAMS ((hash_table_key));
 136 static boolean typename_compare PARAMS ((hash_table_key, hash_table_key));
 137 static void push_binding PARAMS ((tree, tree, struct binding_level*));
 138 static int add_binding PARAMS ((tree, tree));
 139 static void pop_binding PARAMS ((tree, tree));
 140 static tree local_variable_p_walkfn PARAMS ((tree *, int *, void *));
 141 static tree find_binding PARAMS ((tree, tree));
 142 static tree select_decl PARAMS ((tree, int));
 143 static int lookup_flags PARAMS ((int, int));
 144 static tree qualify_lookup PARAMS ((tree, int));
 145 static tree record_builtin_java_type PARAMS ((const char *, int));
 146 static const char *tag_name PARAMS ((enum tag_types code));
 147 static void find_class_binding_level PARAMS ((void));
 148 static struct binding_level *innermost_nonclass_level PARAMS ((void));
 149 static void warn_about_implicit_typename_lookup PARAMS ((tree, tree));
 150 static int walk_namespaces_r PARAMS ((tree, walk_namespaces_fn, void *));
 151 static int walk_globals_r PARAMS ((tree, void *));
 152 static void add_decl_to_level PARAMS ((tree, struct binding_level *));
 153 static tree make_label_decl PARAMS ((tree, int));
 154 static void use_label PARAMS ((tree));
 155 static void check_previous_goto_1 PARAMS ((tree, struct binding_level *, tree,
 156                                            const char *, int));
 157 static void check_previous_goto PARAMS ((struct named_label_use_list *));
 158 static void check_switch_goto PARAMS ((struct binding_level *));
 159 static void check_previous_gotos PARAMS ((tree));
 160 static void pop_label PARAMS ((tree, tree));
 161 static void pop_labels PARAMS ((tree));
 162 static void maybe_deduce_size_from_array_init PARAMS ((tree, tree));
 163 static void layout_var_decl PARAMS ((tree));
 164 static void maybe_commonize_var PARAMS ((tree));
 165 static tree check_initializer PARAMS ((tree, tree));
 166 static void make_rtl_for_nonlocal_decl PARAMS ((tree, tree, const char *));
 167 static void push_cp_function_context PARAMS ((struct function *));
 168 static void pop_cp_function_context PARAMS ((struct function *));
 169 static void mark_binding_level PARAMS ((void *));
 170 static void mark_named_label_lists PARAMS ((void *, void *));
 171 static void mark_cp_function_context PARAMS ((struct function *));
 172 static void mark_saved_scope PARAMS ((void *));
 173 static void mark_lang_function PARAMS ((struct language_function *));
 174 static void mark_stmt_tree PARAMS ((struct stmt_tree *));
 175 static void save_function_data PARAMS ((tree));
 176 static void check_function_type PARAMS ((tree));
 177 static void destroy_local_var PARAMS ((tree));
 178 static void finish_constructor_body PARAMS ((void));
 179 static void finish_destructor_body PARAMS ((void));
 180 static tree create_array_type_for_decl PARAMS ((tree, tree, tree));
 181 static tree get_atexit_node PARAMS ((void));
 182 static tree get_dso_handle_node PARAMS ((void));
 183 static tree start_cleanup_fn PARAMS ((void));
 184 static void end_cleanup_fn PARAMS ((void));
 185 static tree cp_make_fname_decl PARAMS ((tree, const char *, int));
 186 static void initialize_predefined_identifiers PARAMS ((void));
 187 static tree check_special_function_return_type
 188   PARAMS ((special_function_kind, tree, tree, tree));
 189 static tree push_cp_library_fn PARAMS ((enum tree_code, tree));
 190 static tree build_cp_library_fn PARAMS ((tree, enum tree_code, tree));
 191
 192 #if defined (DEBUG_CP_BINDING_LEVELS)
 193 static void indent PARAMS ((void));
 194 #endif
 195
 196 /* Erroneous argument lists can use this *IFF* they do not modify it.  */
 197 tree error_mark_list;
 198
 199 /* The following symbols are subsumed in the cp_global_trees array, and
 200    listed here individually for documentation purposes.
 201
 202    C++ extensions
 203         tree wchar_decl_node;
 204         tree void_zero_node;
 205
 206         tree vtable_entry_type;
 207         tree delta_type_node;
 208 #if 0
 209    Old rtti stuff.
 210         tree __baselist_desc_type_node;
 211         tree __i_desc_type_node, __m_desc_type_node;
 212         tree __t_desc_array_type, __i_desc_array_type, __m_desc_array_type;
 213 #endif
 214         tree __t_desc_type_node;
 215 #if 0
 216         tree __tp_desc_type_node;
 217 #endif
 218         tree ti_desc_type_node;
 219         tree bltn_desc_type_node, ptr_desc_type_node;
 220         tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
 221         tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
 222         tree ptm_desc_type_node;
 223         tree base_desc_type_node;
 224 #if 0
 225    Not needed yet?  May be needed one day?
 226         tree __bltn_desc_array_type, __user_desc_array_type, __class_desc_array_type;
 227         tree __ptr_desc_array_type, __attr_dec_array_type, __func_desc_array_type;
 228         tree __ptmf_desc_array_type, __ptmd_desc_array_type;
 229 #endif
 230
 231         tree class_type_node, record_type_node, union_type_node, enum_type_node;
 232         tree unknown_type_node;
 233
 234    Array type `vtable_entry_type[]'
 235
 236         tree vtbl_type_node;
 237         tree vtbl_ptr_type_node;
 238
 239    Namespaces,
 240
 241         tree std_node;
 242         tree abi_node;
 243
 244    A FUNCTION_DECL which can call `abort'.  Not necessarily the
 245    one that the user will declare, but sufficient to be called
 246    by routines that want to abort the program.
 247
 248         tree abort_fndecl;
 249
 250    The FUNCTION_DECL for the default `::operator delete'.
 251
 252         tree global_delete_fndecl;
 253
 254    Used by RTTI
 255         tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
 256         tree tinfo_var_id;
 257
 258 */
 259
 260 tree cp_global_trees[CPTI_MAX];
 261
 262 /* Indicates that there is a type value in some namespace, although
 263    that is not necessarily in scope at the moment.  */
 264
 265 static tree global_type_node;
 266
 267 /* Namespace std.  */
 268 int in_std;
 269
 270 /* Expect only namespace names now. */
 271 static int only_namespace_names;
 272
 273 /* If original DECL_RESULT of current function was a register,
 274    but due to being an addressable named return value, would up
 275    on the stack, this variable holds the named return value's
 276    original location.  */
 277
 278 #define original_result_rtx cp_function_chain->x_result_rtx
 279
 280 /* Used only for jumps to as-yet undefined labels, since jumps to
 281    defined labels can have their validity checked immediately.  */
 282
 283 struct named_label_use_list
 284 {
 285   struct binding_level *binding_level;
 286   tree names_in_scope;
 287   tree label_decl;
 288   const char *filename_o_goto;
 289   int lineno_o_goto;
 290   struct named_label_use_list *next;
 291 };
 292
 293 #define named_label_uses cp_function_chain->x_named_label_uses
 294
 295 /* A list of objects which have constructors or destructors
 296    which reside in the global scope.  The decl is stored in
 297    the TREE_VALUE slot and the initializer is stored
 298    in the TREE_PURPOSE slot.  */
 299 tree static_aggregates;
 300
 301 /* -- end of C++ */
 302
 303 /* A node for the integer constants 2, and 3.  */
 304
 305 tree integer_two_node, integer_three_node;
 306
 307 /* Parsing a function declarator leaves here a chain of structure
 308    and enum types declared in the parmlist.  */
 309
 310 static tree last_function_parm_tags;
 311
 312 /* Similar, for last_function_parm_tags.  */
 313 tree last_function_parms;
 314 static tree current_function_parm_tags;
 315
 316 /* A list of all LABEL_DECLs in the function that have names.  Here so
 317    we can clear out their names' definitions at the end of the
 318    function, and so we can check the validity of jumps to these labels.  */
 319
 320 struct named_label_list
 321 {
 322   struct binding_level *binding_level;
 323   tree names_in_scope;
 324   tree old_value;
 325   tree label_decl;
 326   tree bad_decls;
 327   int eh_region;
 328   struct named_label_list *next;
 329 };
 330
 331 #define named_labels cp_function_chain->x_named_labels
 332
 333 /* Set to 0 at beginning of a function definition, and whenever
 334    a label (case or named) is defined.  Set to value of expression
 335    returned from function when that value can be transformed into
 336    a named return value.  */
 337
 338 tree current_function_return_value;
 339
 340 /* Nonzero means use the ISO C94 dialect of C.  */
 341
 342 int flag_isoc94;
 343
 344 /* Nonzero means use the ISO C99 dialect of C.  */
 345
 346 int flag_isoc99;
 347
 348 /* Nonzero means give `double' the same size as `float'.  */
 349
 350 extern int flag_short_double;
 351
 352 /* Nonzero means don't recognize any builtin functions.  */
 353
 354 extern int flag_no_builtin;
 355
 356 /* Nonzero means don't recognize the non-ANSI builtin functions.
 357    -ansi sets this.  */
 358
 359 extern int flag_no_nonansi_builtin;
 360
 361 /* Nonzero if we want to conserve space in the .o files.  We do this
 362    by putting uninitialized data and runtime initialized data into
 363    .common instead of .data at the expense of not flagging multiple
 364    definitions.  */
 365 extern int flag_conserve_space;
 366 \f
 367 /* C and C++ flags are in decl2.c.  */
 368
 369 /* Flag used when debugging spew.c */
 370
 371 extern int spew_debug;
 372
 373 /* A expression of value 0 with the same precision as a sizetype
 374    node, but signed.  */
 375 tree signed_size_zero_node;
 376
 377 /* The name of the anonymous namespace, throughout this translation
 378    unit.  */
 379 tree anonymous_namespace_name;
 380
 381 /* The number of function bodies which we are currently processing.
 382    (Zero if we are at namespace scope, one inside the body of a
 383    function, two inside the body of a function in a local class, etc.)  */
 384 int function_depth;
 385 \f
 386 /* For each binding contour we allocate a binding_level structure
 387    which records the names defined in that contour.
 388    Contours include:
 389     0) the global one
 390     1) one for each function definition,
 391        where internal declarations of the parameters appear.
 392     2) one for each compound statement,
 393        to record its declarations.
 394
 395    The current meaning of a name can be found by searching the levels
 396    from the current one out to the global one.
 397
 398    Off to the side, may be the class_binding_level.  This exists only
 399    to catch class-local declarations.  It is otherwise nonexistent.
 400
 401    Also there may be binding levels that catch cleanups that must be
 402    run when exceptions occur.  Thus, to see whether a name is bound in
 403    the current scope, it is not enough to look in the
 404    CURRENT_BINDING_LEVEL.  You should use lookup_name_current_level
 405    instead.  */
 406
 407 /* Note that the information in the `names' component of the global contour
 408    is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers.  */
 409
 410 struct binding_level
 411   {
 412     /* A chain of _DECL nodes for all variables, constants, functions,
 413        and typedef types.  These are in the reverse of the order
 414        supplied.  There may be OVERLOADs on this list, too, but they
 415        are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD.  */
 416     tree names;
 417
 418     /* A list of structure, union and enum definitions, for looking up
 419        tag names.
 420        It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
 421        or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
 422        or ENUMERAL_TYPE node.
 423
 424        C++: the TREE_VALUE nodes can be simple types for
 425        component_bindings.  */
 426     tree tags;
 427
 428     /* A list of USING_DECL nodes. */
 429     tree usings;
 430
 431     /* A list of used namespaces. PURPOSE is the namespace,
 432        VALUE the common ancestor with this binding_level's namespace. */
 433     tree using_directives;
 434
 435     /* If this binding level is the binding level for a class, then
 436        class_shadowed is a TREE_LIST.  The TREE_PURPOSE of each node
 437        is the name of an entity bound in the class; the TREE_VALUE is
 438        the IDENTIFIER_CLASS_VALUE before we entered the class.  Thus,
 439        when leaving class scope, we can restore the
 440        IDENTIFIER_CLASS_VALUE by walking this list.  The TREE_TYPE is
 441        the DECL bound by this name in the class.  */
 442     tree class_shadowed;
 443
 444     /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
 445        is used for all binding levels.  */
 446     tree type_shadowed;
 447
 448     /* A TREE_LIST.  Each TREE_VALUE is the LABEL_DECL for a local
 449        label in this scope.  The TREE_PURPOSE is the previous value of
 450        the IDENTIFIER_LABEL VALUE.  */
 451     tree shadowed_labels;
 452
 453     /* For each level (except not the global one),
 454        a chain of BLOCK nodes for all the levels
 455        that were entered and exited one level down.  */
 456     tree blocks;
 457
 458     /* The BLOCK node for this level, if one has been preallocated.
 459        If 0, the BLOCK is allocated (if needed) when the level is popped.  */
 460     tree this_block;
 461
 462     /* The _TYPE node for this level, if parm_flag == 2.  */
 463     tree this_class;
 464
 465     /* The binding level which this one is contained in (inherits from).  */
 466     struct binding_level *level_chain;
 467
 468     /* List of decls in `names' that have incomplete
 469        structure or union types.  */
 470     tree incomplete;
 471
 472     /* List of VAR_DECLS saved from a previous for statement.
 473        These would be dead in ISO-conforming code, but might
 474        be referenced in ARM-era code.  These are stored in a
 475        TREE_LIST; the TREE_VALUE is the actual declaration.  */
 476     tree dead_vars_from_for;
 477
 478     /* 1 for the level that holds the parameters of a function.
 479        2 for the level that holds a class declaration.  */
 480     unsigned parm_flag : 2;
 481
 482     /* 1 means make a BLOCK for this level regardless of all else.
 483        2 for temporary binding contours created by the compiler.  */
 484     unsigned keep : 2;
 485
 486     /* Nonzero if this level "doesn't exist" for tags.  */
 487     unsigned tag_transparent : 1;
 488
 489     /* Nonzero if this level can safely have additional
 490        cleanup-needing variables added to it.  */
 491     unsigned more_cleanups_ok : 1;
 492     unsigned have_cleanups : 1;
 493
 494     /* Nonzero if this scope is for storing the decls for template
 495        parameters and generic decls; these decls will be discarded and
 496        replaced with a TEMPLATE_DECL.  */
 497     unsigned template_parms_p : 1;
 498
 499     /* Nonzero if this scope corresponds to the `<>' in a
 500        `template <>' clause.  Whenever this flag is set,
 501        TEMPLATE_PARMS_P will be set as well.  */
 502     unsigned template_spec_p : 1;
 503
 504     /* This is set for a namespace binding level.  */
 505     unsigned namespace_p : 1;
 506
 507     /* True if this level is that of a for-statement where we need to
 508        worry about ambiguous (ARM or ISO) scope rules.  */
 509     unsigned is_for_scope : 1;
 510
 511     /* True if this level corresponds to an EH region, as for a try block.
 512        Currently this information is only available while building the
 513        tree structure.  */
 514     unsigned eh_region : 1;
 515
 516     /* Four bits left for this word.  */
 517
 518 #if defined(DEBUG_CP_BINDING_LEVELS)
 519     /* Binding depth at which this level began.  */
 520     unsigned binding_depth;
 521 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 522   };
 523
 524 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
 525
 526 /* The binding level currently in effect.  */
 527
 528 #define current_binding_level                   \
 529   (cfun                                         \
 530    ? cp_function_chain->bindings                \
 531    : scope_chain->bindings)
 532
 533 /* The binding level of the current class, if any.  */
 534
 535 #define class_binding_level scope_chain->class_bindings
 536
 537 /* A chain of binding_level structures awaiting reuse.  */
 538
 539 static struct binding_level *free_binding_level;
 540
 541 /* The outermost binding level, for names of file scope.
 542    This is created when the compiler is started and exists
 543    through the entire run.  */
 544
 545 static struct binding_level *global_binding_level;
 546
 547 /* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
 548
 549 static int keep_next_level_flag;
 550
 551 #if defined(DEBUG_CP_BINDING_LEVELS)
 552 static int binding_depth = 0;
 553 static int is_class_level = 0;
 554
 555 static void
 556 indent ()
 557 {
 558   register unsigned i;
 559
 560   for (i = 0; i < binding_depth*2; i++)
 561     putc (' ', stderr);
 562 }
 563 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 564
 565 static tree pushdecl_with_scope PARAMS ((tree, struct binding_level *));
 566
 567 static void
 568 push_binding_level (newlevel, tag_transparent, keep)
 569      struct binding_level *newlevel;
 570      int tag_transparent, keep;
 571 {
 572   /* Add this level to the front of the chain (stack) of levels that
 573      are active.  */
 574   bzero ((char*) newlevel, sizeof (struct binding_level));
 575   newlevel->level_chain = current_binding_level;
 576   current_binding_level = newlevel;
 577   newlevel->tag_transparent = tag_transparent;
 578   newlevel->more_cleanups_ok = 1;
 579
 580   newlevel->keep = keep;
 581 #if defined(DEBUG_CP_BINDING_LEVELS)
 582   newlevel->binding_depth = binding_depth;
 583   indent ();
 584   fprintf (stderr, "push %s level 0x%08x line %d\n",
 585            (is_class_level) ? "class" : "block", newlevel, lineno);
 586   is_class_level = 0;
 587   binding_depth++;
 588 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 589 }
 590
 591 /* Find the innermost enclosing class scope, and reset
 592    CLASS_BINDING_LEVEL appropriately.  */
 593
 594 static void
 595 find_class_binding_level ()
 596 {
 597   struct binding_level *level = current_binding_level;
 598
 599   while (level && level->parm_flag != 2)
 600     level = level->level_chain;
 601   if (level && level->parm_flag == 2)
 602     class_binding_level = level;
 603   else
 604     class_binding_level = 0;
 605 }
 606
 607 static void
 608 pop_binding_level ()
 609 {
 610   if (global_binding_level)
 611     {
 612       /* Cannot pop a level, if there are none left to pop.  */
 613       if (current_binding_level == global_binding_level)
 614         my_friendly_abort (123);
 615     }
 616   /* Pop the current level, and free the structure for reuse.  */
 617 #if defined(DEBUG_CP_BINDING_LEVELS)
 618   binding_depth--;
 619   indent ();
 620   fprintf (stderr, "pop  %s level 0x%08x line %d\n",
 621           (is_class_level) ? "class" : "block",
 622           current_binding_level, lineno);
 623   if (is_class_level != (current_binding_level == class_binding_level))
 624     {
 625       indent ();
 626       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 627     }
 628   is_class_level = 0;
 629 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 630   {
 631     register struct binding_level *level = current_binding_level;
 632     current_binding_level = current_binding_level->level_chain;
 633     level->level_chain = free_binding_level;
 634 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
 635     if (level->binding_depth != binding_depth)
 636       abort ();
 637 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 638     free_binding_level = level;
 639     find_class_binding_level ();
 640   }
 641 }
 642
 643 static void
 644 suspend_binding_level ()
 645 {
 646   if (class_binding_level)
 647     current_binding_level = class_binding_level;
 648
 649   if (global_binding_level)
 650     {
 651       /* Cannot suspend a level, if there are none left to suspend.  */
 652       if (current_binding_level == global_binding_level)
 653         my_friendly_abort (123);
 654     }
 655   /* Suspend the current level.  */
 656 #if defined(DEBUG_CP_BINDING_LEVELS)
 657   binding_depth--;
 658   indent ();
 659   fprintf (stderr, "suspend  %s level 0x%08x line %d\n",
 660           (is_class_level) ? "class" : "block",
 661           current_binding_level, lineno);
 662   if (is_class_level != (current_binding_level == class_binding_level))
 663     {
 664       indent ();
 665       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 666     }
 667   is_class_level = 0;
 668 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 669   current_binding_level = current_binding_level->level_chain;
 670   find_class_binding_level ();
 671 }
 672
 673 static void
 674 resume_binding_level (b)
 675      struct binding_level *b;
 676 {
 677   /* Resuming binding levels is meant only for namespaces,
 678      and those cannot nest into classes. */
 679   my_friendly_assert(!class_binding_level, 386);
 680   /* Also, resuming a non-directly nested namespace is a no-no.  */
 681   my_friendly_assert(b->level_chain == current_binding_level, 386);
 682   current_binding_level = b;
 683 #if defined(DEBUG_CP_BINDING_LEVELS)
 684   b->binding_depth = binding_depth;
 685   indent ();
 686   fprintf (stderr, "resume %s level 0x%08x line %d\n",
 687            (is_class_level) ? "class" : "block", b, lineno);
 688   is_class_level = 0;
 689   binding_depth++;
 690 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 691 }
 692 \f
 693 /* Create a new `struct binding_level'.  */
 694
 695 static
 696 struct binding_level *
 697 make_binding_level ()
 698 {
 699   /* NOSTRICT */
 700   return (struct binding_level *) xmalloc (sizeof (struct binding_level));
 701 }
 702
 703 /* Nonzero if we are currently in the global binding level.  */
 704
 705 int
 706 global_bindings_p ()
 707 {
 708   return current_binding_level == global_binding_level;
 709 }
 710
 711 /* Return the innermost binding level that is not for a class scope.  */
 712
 713 static struct binding_level *
 714 innermost_nonclass_level ()
 715 {
 716   struct binding_level *b;
 717
 718   b = current_binding_level;
 719   while (b->parm_flag == 2)
 720     b = b->level_chain;
 721
 722   return b;
 723 }
 724
 725 /* Nonzero if we are currently in a toplevel binding level.  This
 726    means either the global binding level or a namespace in a toplevel
 727    binding level.  Since there are no non-toplevel namespace levels,
 728    this really means any namespace or template parameter level.  We
 729    also include a class whose context is toplevel.  */
 730
 731 int
 732 toplevel_bindings_p ()
 733 {
 734   struct binding_level *b = innermost_nonclass_level ();
 735
 736   return b->namespace_p || b->template_parms_p;
 737 }
 738
 739 /* Nonzero if this is a namespace scope, or if we are defining a class
 740    which is itself at namespace scope, or whose enclosing class is
 741    such a class, etc.  */
 742
 743 int
 744 namespace_bindings_p ()
 745 {
 746   struct binding_level *b = innermost_nonclass_level ();
 747
 748   return b->namespace_p;
 749 }
 750
 751 /* If KEEP is non-zero, make a BLOCK node for the next binding level,
 752    unconditionally.  Otherwise, use the normal logic to decide whether
 753    or not to create a BLOCK.  */
 754
 755 void
 756 keep_next_level (keep)
 757      int keep;
 758 {
 759   keep_next_level_flag = keep;
 760 }
 761
 762 /* Nonzero if the current level needs to have a BLOCK made.  */
 763
 764 int
 765 kept_level_p ()
 766 {
 767   return (current_binding_level->blocks != NULL_TREE
 768           || current_binding_level->keep
 769           || current_binding_level->names != NULL_TREE
 770           || (current_binding_level->tags != NULL_TREE
 771               && !current_binding_level->tag_transparent));
 772 }
 773
 774 static void
 775 declare_namespace_level ()
 776 {
 777   current_binding_level->namespace_p = 1;
 778 }
 779
 780 /* Returns non-zero if this scope was created to store template
 781    parameters.  */
 782
 783 int
 784 template_parm_scope_p ()
 785 {
 786   return current_binding_level->template_parms_p;
 787 }
 788
 789 /* Returns the kind of template specialization we are currently
 790    processing, given that it's declaration contained N_CLASS_SCOPES
 791    explicit scope qualifications.  */
 792
 793 tmpl_spec_kind
 794 current_tmpl_spec_kind (n_class_scopes)
 795      int n_class_scopes;
 796 {
 797   int n_template_parm_scopes = 0;
 798   int seen_specialization_p = 0;
 799   int innermost_specialization_p = 0;
 800   struct binding_level *b;
 801
 802   /* Scan through the template parameter scopes.  */
 803   for (b = current_binding_level; b->template_parms_p; b = b->level_chain)
 804     {
 805       /* If we see a specialization scope inside a parameter scope,
 806          then something is wrong.  That corresponds to a declaration
 807          like:
 808
 809             template <class T> template <> ...
 810
 811          which is always illegal since [temp.expl.spec] forbids the
 812          specialization of a class member template if the enclosing
 813          class templates are not explicitly specialized as well.  */
 814       if (b->template_spec_p)
 815         {
 816           if (n_template_parm_scopes == 0)
 817             innermost_specialization_p = 1;
 818           else
 819             seen_specialization_p = 1;
 820         }
 821       else if (seen_specialization_p == 1)
 822         return tsk_invalid_member_spec;
 823
 824       ++n_template_parm_scopes;
 825     }
 826
 827   /* Handle explicit instantiations.  */
 828   if (processing_explicit_instantiation)
 829     {
 830       if (n_template_parm_scopes != 0)
 831         /* We've seen a template parameter list during an explicit
 832            instantiation.  For example:
 833
 834              template <class T> template void f(int);
 835
 836            This is erroneous.  */
 837         return tsk_invalid_expl_inst;
 838       else
 839         return tsk_expl_inst;
 840     }
 841
 842   if (n_template_parm_scopes < n_class_scopes)
 843     /* We've not seen enough template headers to match all the
 844        specialized classes present.  For example:
 845
 846          template <class T> void R<T>::S<T>::f(int);
 847
 848        This is illegal; there needs to be one set of template
 849        parameters for each class.  */
 850     return tsk_insufficient_parms;
 851   else if (n_template_parm_scopes == n_class_scopes)
 852     /* We're processing a non-template declaration (even though it may
 853        be a member of a template class.)  For example:
 854
 855          template <class T> void S<T>::f(int);
 856
 857        The `class T' maches the `S<T>', leaving no template headers
 858        corresponding to the `f'.  */
 859     return tsk_none;
 860   else if (n_template_parm_scopes > n_class_scopes + 1)
 861     /* We've got too many template headers.  For example:
 862
 863          template <> template <class T> void f (T);
 864
 865        There need to be more enclosing classes.  */
 866     return tsk_excessive_parms;
 867   else
 868     /* This must be a template.  It's of the form:
 869
 870          template <class T> template <class U> void S<T>::f(U);
 871
 872        This is a specialization if the innermost level was a
 873        specialization; otherwise it's just a definition of the
 874        template.  */
 875     return innermost_specialization_p ? tsk_expl_spec : tsk_template;
 876 }
 877
 878 void
 879 set_class_shadows (shadows)
 880      tree shadows;
 881 {
 882   class_binding_level->class_shadowed = shadows;
 883 }
 884
 885 /* Enter a new binding level.
 886    If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
 887    not for that of tags.  */
 888
 889 void
 890 pushlevel (tag_transparent)
 891      int tag_transparent;
 892 {
 893   struct binding_level *newlevel;
 894
 895   if (cfun && !doing_semantic_analysis_p ())
 896     return;
 897
 898   /* Reuse or create a struct for this binding level.  */
 899 #if defined(DEBUG_CP_BINDING_LEVELS)
 900   if (0)
 901 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
 902   if (free_binding_level)
 903 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
 904     {
 905       newlevel = free_binding_level;
 906       free_binding_level = free_binding_level->level_chain;
 907     }
 908   else
 909     newlevel = make_binding_level ();
 910
 911   push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
 912   GNU_xref_start_scope ((HOST_WIDE_INT) newlevel);
 913   keep_next_level_flag = 0;
 914 }
 915
 916 /* Enter a new scope.  The KIND indicates what kind of scope is being
 917    created.  */
 918
 919 void
 920 begin_scope (sk)
 921      scope_kind sk;
 922 {
 923   pushlevel (0);
 924
 925   switch (sk)
 926     {
 927     case sk_template_spec:
 928       current_binding_level->template_spec_p = 1;
 929       /* Fall through.  */
 930
 931     case sk_template_parms:
 932       current_binding_level->template_parms_p = 1;
 933       break;
 934
 935     default:
 936       my_friendly_abort (20000309);
 937     }
 938 }
 939
 940 /* Exit the current scope.  */
 941
 942 void
 943 finish_scope ()
 944 {
 945   poplevel (0, 0, 0);
 946 }
 947
 948 void
 949 note_level_for_for ()
 950 {
 951   current_binding_level->is_for_scope = 1;
 952 }
 953
 954 /* Record that the current binding level represents a try block.  */
 955
 956 void
 957 note_level_for_eh ()
 958 {
 959   current_binding_level->eh_region = 1;
 960 }
 961
 962 /* For a binding between a name and an entity at a block scope,
 963    this is the `struct binding_level' for the block.  */
 964 #define BINDING_LEVEL(NODE) \
 965    (((struct tree_binding*)NODE)->scope.level)
 966
 967 /* Make DECL the innermost binding for ID.  The LEVEL is the binding
 968    level at which this declaration is being bound.  */
 969
 970 static void
 971 push_binding (id, decl, level)
 972      tree id;
 973      tree decl;
 974      struct binding_level* level;
 975 {
 976   tree binding;
 977
 978   binding = make_node (CPLUS_BINDING);
 979
 980   /* Now, fill in the binding information.  */
 981   BINDING_VALUE (binding) = decl;
 982   BINDING_TYPE (binding) = NULL_TREE;
 983   BINDING_LEVEL (binding) = level;
 984   INHERITED_VALUE_BINDING_P (binding) = 0;
 985   LOCAL_BINDING_P (binding) = (level != class_binding_level);
 986   BINDING_HAS_LEVEL_P (binding) = 1;
 987
 988   /* And put it on the front of the list of bindings for ID.  */
 989   TREE_CHAIN (binding) = IDENTIFIER_BINDING (id);
 990   IDENTIFIER_BINDING (id) = binding;
 991 }
 992
 993 /* ID is already bound in the current scope.  But, DECL is an
 994    additional binding for ID in the same scope.  This is the `struct
 995    stat' hack whereby a non-typedef class-name or enum-name can be
 996    bound at the same level as some other kind of entity.  It's the
 997    responsibility of the caller to check that inserting this name is
 998    legal here.  Returns nonzero if the new binding was successful.  */
 999 static int
1000 add_binding (id, decl)
1001      tree id;
1002      tree decl;
1003 {
1004   tree binding = IDENTIFIER_BINDING (id);
1005   int ok = 1;
1006
1007   if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
1008     /* The new name is the type name.  */
1009     BINDING_TYPE (binding) = decl;
1010   else if (!BINDING_VALUE (binding))
1011     /* This situation arises when push_class_level_binding moves an
1012        inherited type-binding out of the way to make room for a new
1013        value binding.  */
1014     BINDING_VALUE (binding) = decl;
1015   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
1016            && DECL_ARTIFICIAL (BINDING_VALUE (binding)))
1017     {
1018       /* The old binding was a type name.  It was placed in
1019          BINDING_VALUE because it was thought, at the point it was
1020          declared, to be the only entity with such a name.  Move the
1021          type name into the type slot; it is now hidden by the new
1022          binding.  */
1023       BINDING_TYPE (binding) = BINDING_VALUE (binding);
1024       BINDING_VALUE (binding) = decl;
1025       INHERITED_VALUE_BINDING_P (binding) = 0;
1026     }
1027   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
1028            && TREE_CODE (decl) == TYPE_DECL
1029            && DECL_NAME (decl) == DECL_NAME (BINDING_VALUE (binding))
1030            && same_type_p (TREE_TYPE (decl),
1031                            TREE_TYPE (BINDING_VALUE (binding))))
1032     /* We have two typedef-names, both naming the same type to have
1033        the same name.  This is OK because of:
1034
1035          [dcl.typedef]
1036
1037          In a given scope, a typedef specifier can be used to redefine
1038          the name of any type declared in that scope to refer to the
1039          type to which it already refers.  */
1040     ok = 0;
1041   /* There can be two block-scope declarations of the same variable,
1042      so long as they are `extern' declarations.  */
1043   else if (TREE_CODE (decl) == VAR_DECL
1044            && TREE_CODE (BINDING_VALUE (binding)) == VAR_DECL
1045            && DECL_EXTERNAL (decl)
1046            && DECL_EXTERNAL (BINDING_VALUE (binding)))
1047     {
1048       duplicate_decls (decl, BINDING_VALUE (binding));
1049       ok = 0;
1050     }
1051   else
1052     {
1053       cp_error ("declaration of `%#D'", decl);
1054       cp_error_at ("conflicts with previous declaration `%#D'",
1055                    BINDING_VALUE (binding));
1056       ok = 0;
1057     }
1058
1059   return ok;
1060 }
1061
1062 /* Add DECL to the list of things declared in B.  */
1063
1064 static void
1065 add_decl_to_level (decl, b)
1066      tree decl;
1067      struct binding_level *b;
1068 {
1069   /* We build up the list in reverse order, and reverse it later if
1070      necessary.  */
1071   TREE_CHAIN (decl) = b->names;
1072   b->names = decl;
1073 }
1074
1075 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1076    binding level.  If PUSH_USING is set in FLAGS, we know that DECL
1077    doesn't really belong to this binding level, that it got here
1078    through a using-declaration.  */
1079
1080 void
1081 push_local_binding (id, decl, flags)
1082      tree id;
1083      tree decl;
1084      int flags;
1085 {
1086   struct binding_level *b;
1087
1088   /* Skip over any local classes.  This makes sense if we call
1089      push_local_binding with a friend decl of a local class.  */
1090   b = current_binding_level;
1091   while (b->parm_flag == 2)
1092     b = b->level_chain;
1093
1094   if (lookup_name_current_level (id))
1095     {
1096       /* Supplement the existing binding.  */
1097       if (!add_binding (id, decl))
1098         /* It didn't work.  Something else must be bound at this
1099            level.  Do not add DECL to the list of things to pop
1100            later.  */
1101         return;
1102     }
1103   else
1104     /* Create a new binding.  */
1105     push_binding (id, decl, b);
1106
1107   if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1108     /* We must put the OVERLOAD into a TREE_LIST since the
1109        TREE_CHAIN of an OVERLOAD is already used.  Similarly for
1110        decls that got here through a using-declaration.  */
1111     decl = build_tree_list (NULL_TREE, decl);
1112
1113   /* And put DECL on the list of things declared by the current
1114      binding level.  */
1115   add_decl_to_level (decl, b);
1116 }
1117
1118 /* Bind DECL to ID in the class_binding_level.  Returns nonzero if the
1119    binding was successful.  */
1120
1121 int
1122 push_class_binding (id, decl)
1123      tree id;
1124      tree decl;
1125 {
1126   int result = 1;
1127   tree binding = IDENTIFIER_BINDING (id);
1128   tree context;
1129
1130   /* Note that we declared this value so that we can issue an error if
1131      this an illegal redeclaration of a name already used for some
1132      other purpose.  */
1133   note_name_declared_in_class (id, decl);
1134
1135   if (binding && BINDING_LEVEL (binding) == class_binding_level)
1136     /* Supplement the existing binding.  */
1137     result = add_binding (id, decl);
1138   else
1139     /* Create a new binding.  */
1140     push_binding (id, decl, class_binding_level);
1141
1142   /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1143      class-level declaration.  Note that we do not use DECL here
1144      because of the possibility of the `struct stat' hack; if DECL is
1145      a class-name or enum-name we might prefer a field-name, or some
1146      such.  */
1147   IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
1148
1149   /* If this is a binding from a base class, mark it as such.  */
1150   binding = IDENTIFIER_BINDING (id);
1151   if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
1152     {
1153       /* Any implicit typename must be from a base-class.  The
1154          context for an implicit typename declaration is always
1155          the derived class in which the lookup was done, so the checks
1156          based on the context of DECL below will not trigger.  */
1157       if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl))
1158         INHERITED_VALUE_BINDING_P (binding) = 1;
1159       else
1160         {
1161           if (TREE_CODE (decl) == OVERLOAD)
1162             context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
1163           else
1164             {
1165               my_friendly_assert (DECL_P (decl), 0);
1166               context = CP_DECL_CONTEXT (decl);
1167             }
1168
1169           if (is_properly_derived_from (current_class_type, context))
1170             INHERITED_VALUE_BINDING_P (binding) = 1;
1171           else
1172             INHERITED_VALUE_BINDING_P (binding) = 0;
1173         }
1174     }
1175   else if (BINDING_VALUE (binding) == decl)
1176     /* We only encounter a TREE_LIST when push_class_decls detects an
1177        ambiguity.  Such an ambiguity can be overridden by a definition
1178        in this class.  */
1179     INHERITED_VALUE_BINDING_P (binding) = 1;
1180
1181   return result;
1182 }
1183
1184 /* Remove the binding for DECL which should be the innermost binding
1185    for ID.  */
1186
1187 static void
1188 pop_binding (id, decl)
1189      tree id;
1190      tree decl;
1191 {
1192   tree binding;
1193
1194   if (id == NULL_TREE)
1195     /* It's easiest to write the loops that call this function without
1196        checking whether or not the entities involved have names.  We
1197        get here for such an entity.  */
1198     return;
1199
1200   /* Get the innermost binding for ID.  */
1201   binding = IDENTIFIER_BINDING (id);
1202
1203   /* The name should be bound.  */
1204   my_friendly_assert (binding != NULL_TREE, 0);
1205
1206   /* The DECL will be either the ordinary binding or the type
1207      binding for this identifier.  Remove that binding.  */
1208   if (BINDING_VALUE (binding) == decl)
1209     BINDING_VALUE (binding) = NULL_TREE;
1210   else if (BINDING_TYPE (binding) == decl)
1211     BINDING_TYPE (binding) = NULL_TREE;
1212   else
1213     my_friendly_abort (0);
1214
1215   if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
1216     /* We're completely done with the innermost binding for this
1217        identifier.  Unhook it from the list of bindings.  */
1218     IDENTIFIER_BINDING (id) = TREE_CHAIN (binding);
1219 }
1220
1221 /* When a label goes out of scope, check to see if that label was used
1222    in a valid manner, and issue any appropriate warnings or errors.  */
1223
1224 static void
1225 pop_label (label, old_value)
1226      tree label;
1227      tree old_value;
1228 {
1229   if (!processing_template_decl && doing_semantic_analysis_p ())
1230     {
1231       if (DECL_INITIAL (label) == NULL_TREE)
1232         {
1233           cp_error_at ("label `%D' used but not defined", label);
1234           /* Avoid crashing later.  */
1235           define_label (input_filename, 1, DECL_NAME (label));
1236         }
1237       else if (warn_unused_label && !TREE_USED (label))
1238         cp_warning_at ("label `%D' defined but not used", label);
1239     }
1240
1241   SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
1242 }
1243
1244 /* At the end of a function, all labels declared within the fucntion
1245    go out of scope.  BLOCK is the top-level block for the
1246    function.  */
1247
1248 static void
1249 pop_labels (block)
1250      tree block;
1251 {
1252   struct named_label_list *link;
1253
1254   /* Clear out the definitions of all label names, since their scopes
1255      end here.  */
1256   for (link = named_labels; link; link = link->next)
1257     {
1258       pop_label (link->label_decl, link->old_value);
1259       /* Put the labels into the "variables" of the top-level block,
1260          so debugger can see them.  */
1261       TREE_CHAIN (link->label_decl) = BLOCK_VARS (block);
1262       BLOCK_VARS (block) = link->label_decl;
1263     }
1264
1265   named_labels = NULL;
1266 }
1267
1268 /* Exit a binding level.
1269    Pop the level off, and restore the state of the identifier-decl mappings
1270    that were in effect when this level was entered.
1271
1272    If KEEP == 1, this level had explicit declarations, so
1273    and create a "block" (a BLOCK node) for the level
1274    to record its declarations and subblocks for symbol table output.
1275
1276    If FUNCTIONBODY is nonzero, this level is the body of a function,
1277    so create a block as if KEEP were set and also clear out all
1278    label names.
1279
1280    If REVERSE is nonzero, reverse the order of decls before putting
1281    them into the BLOCK.  */
1282
1283 tree
1284 poplevel (keep, reverse, functionbody)
1285      int keep;
1286      int reverse;
1287      int functionbody;
1288 {
1289   register tree link;
1290   /* The chain of decls was accumulated in reverse order.
1291      Put it into forward order, just for cleanliness.  */
1292   tree decls;
1293   int tmp = functionbody;
1294   int real_functionbody;
1295   tree tags;
1296   tree subblocks;
1297   tree block = NULL_TREE;
1298   tree decl;
1299   int block_previously_created;
1300   int leaving_for_scope;
1301
1302   if (cfun && !doing_semantic_analysis_p ())
1303     return NULL_TREE;
1304
1305   my_friendly_assert (current_binding_level->parm_flag != 2,
1306                       19990916);
1307
1308   real_functionbody = (current_binding_level->keep == 2
1309                        ? ((functionbody = 0), tmp) : functionbody);
1310   tags = functionbody >= 0 ? current_binding_level->tags : 0;
1311   subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1312
1313   my_friendly_assert (!current_binding_level->class_shadowed,
1314                       19990414);
1315
1316   /* We used to use KEEP == 2 to indicate that the new block should go
1317      at the beginning of the list of blocks at this binding level,
1318      rather than the end.  This hack is no longer used.  */
1319   my_friendly_assert (keep == 0 || keep == 1, 0);
1320
1321   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
1322                       (HOST_WIDE_INT) current_binding_level->level_chain,
1323                       current_binding_level->parm_flag,
1324                       current_binding_level->keep);
1325
1326   if (current_binding_level->keep == 1)
1327     keep = 1;
1328
1329   /* Any uses of undefined labels, and any defined labels, now operate
1330      under constraints of next binding contour.  */
1331   if (cfun && !functionbody)
1332     {
1333       struct binding_level *level_chain;
1334       level_chain = current_binding_level->level_chain;
1335       if (level_chain)
1336         {
1337           struct named_label_use_list *uses;
1338           struct named_label_list *labels;
1339           for (labels = named_labels; labels; labels = labels->next)
1340             if (labels->binding_level == current_binding_level)
1341               {
1342                 tree decl;
1343                 if (current_binding_level->eh_region)
1344                   labels->eh_region = 1;
1345                 for (decl = labels->names_in_scope; decl;
1346                      decl = TREE_CHAIN (decl))
1347                   if (decl_jump_unsafe (decl))
1348                     labels->bad_decls = tree_cons (NULL_TREE, decl,
1349                                                    labels->bad_decls);
1350                 labels->binding_level = level_chain;
1351                 labels->names_in_scope = level_chain->names;
1352               }
1353
1354           for (uses = named_label_uses; uses; uses = uses->next)
1355             if (uses->binding_level == current_binding_level)
1356               {
1357                 uses->binding_level = level_chain;
1358                 uses->names_in_scope = level_chain->names;
1359               }
1360         }
1361     }
1362
1363   /* Get the decls in the order they were written.
1364      Usually current_binding_level->names is in reverse order.
1365      But parameter decls were previously put in forward order.  */
1366
1367   if (reverse)
1368     current_binding_level->names
1369       = decls = nreverse (current_binding_level->names);
1370   else
1371     decls = current_binding_level->names;
1372
1373   /* Output any nested inline functions within this block
1374      if they weren't already output.  */
1375   for (decl = decls; decl; decl = TREE_CHAIN (decl))
1376     if (TREE_CODE (decl) == FUNCTION_DECL
1377         && ! TREE_ASM_WRITTEN (decl)
1378         && DECL_INITIAL (decl) != NULL_TREE
1379         && TREE_ADDRESSABLE (decl)
1380         && decl_function_context (decl) == current_function_decl)
1381       {
1382         /* If this decl was copied from a file-scope decl
1383            on account of a block-scope extern decl,
1384            propagate TREE_ADDRESSABLE to the file-scope decl.  */
1385         if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1386           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1387         else
1388           {
1389             push_function_context ();
1390             output_inline_function (decl);
1391             pop_function_context ();
1392           }
1393       }
1394
1395   /* When not in function-at-a-time mode, expand_end_bindings will
1396      warn about unused variables.  But, in function-at-a-time mode
1397      expand_end_bindings is not passed the list of variables in the
1398      current scope, and therefore no warning is emitted.  So, we
1399      explicitly warn here.  */
1400   if (!processing_template_decl)
1401     warn_about_unused_variables (getdecls ());
1402
1403   /* If there were any declarations or structure tags in that level,
1404      or if this level is a function body,
1405      create a BLOCK to record them for the life of this function.  */
1406   block = NULL_TREE;
1407   block_previously_created = (current_binding_level->this_block != NULL_TREE);
1408   if (block_previously_created)
1409     block = current_binding_level->this_block;
1410   else if (keep == 1 || functionbody)
1411     block = make_node (BLOCK);
1412   if (block != NULL_TREE)
1413     {
1414       if (block_previously_created)
1415         {
1416           if (decls || tags || subblocks)
1417             {
1418               if (BLOCK_VARS (block))
1419                 warning ("internal compiler error: debugging info corrupted");
1420
1421               BLOCK_VARS (block) = decls;
1422
1423               /* We can have previous subblocks and new subblocks when
1424                  doing fixup_gotos with complex cleanups.  We chain the new
1425                  subblocks onto the end of any pre-existing subblocks.  */
1426               BLOCK_SUBBLOCKS (block) = chainon (BLOCK_SUBBLOCKS (block),
1427                                                  subblocks);
1428             }
1429         }
1430       else
1431         {
1432           BLOCK_VARS (block) = decls;
1433           BLOCK_SUBBLOCKS (block) = subblocks;
1434         }
1435     }
1436
1437   /* In each subblock, record that this is its superior.  */
1438   if (keep >= 0)
1439     for (link = subblocks; link; link = TREE_CHAIN (link))
1440       BLOCK_SUPERCONTEXT (link) = block;
1441
1442   /* We still support the old for-scope rules, whereby the variables
1443      in a for-init statement were in scope after the for-statement
1444      ended.  We only use the new rules in flag_new_for_scope is
1445      nonzero.  */
1446   leaving_for_scope
1447     = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1448
1449   /* Remove declarations for all the DECLs in this level.  */
1450   for (link = decls; link; link = TREE_CHAIN (link))
1451     {
1452       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
1453           && DECL_NAME (link))
1454         {
1455           tree outer_binding
1456             = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1457           tree ns_binding;
1458
1459           if (!outer_binding)
1460             ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1461           else
1462             ns_binding = NULL_TREE;
1463
1464           if (outer_binding
1465               && (BINDING_LEVEL (outer_binding)
1466                   == current_binding_level->level_chain))
1467             /* We have something like:
1468
1469                  int i;
1470                  for (int i; ;);
1471
1472                and we are leaving the `for' scope.  There's no reason to
1473                keep the binding of the inner `i' in this case.  */
1474             pop_binding (DECL_NAME (link), link);
1475           else if ((outer_binding
1476                     && (TREE_CODE (BINDING_VALUE (outer_binding))
1477                         == TYPE_DECL))
1478                    || (ns_binding
1479                        && TREE_CODE (ns_binding) == TYPE_DECL))
1480             /* Here, we have something like:
1481
1482                  typedef int I;
1483
1484                  void f () {
1485                    for (int I; ;);
1486                  }
1487
1488                We must pop the for-scope binding so we know what's a
1489                type and what isn't.  */
1490             pop_binding (DECL_NAME (link), link);
1491           else
1492             {
1493               /* Mark this VAR_DECL as dead so that we can tell we left it
1494                  there only for backward compatibility.  */
1495               DECL_DEAD_FOR_LOCAL (link) = 1;
1496
1497               /* Keep track of what should of have happenned when we
1498                  popped the binding.  */
1499               if (outer_binding && BINDING_VALUE (outer_binding))
1500                 DECL_SHADOWED_FOR_VAR (link)
1501                   = BINDING_VALUE (outer_binding);
1502
1503               /* Add it to the list of dead variables in the next
1504                  outermost binding to that we can remove these when we
1505                  leave that binding.  */
1506               current_binding_level->level_chain->dead_vars_from_for
1507                 = tree_cons (NULL_TREE, link,
1508                              current_binding_level->level_chain->
1509                              dead_vars_from_for);
1510
1511               /* Although we don't pop the CPLUS_BINDING, we do clear
1512                  its BINDING_LEVEL since the level is going away now.  */
1513               BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1514                 = 0;
1515             }
1516         }
1517       else
1518         {
1519           /* Remove the binding.  */
1520           decl = link;
1521           if (TREE_CODE (decl) == TREE_LIST)
1522             decl = TREE_VALUE (decl);
1523           if (DECL_P (decl))
1524             pop_binding (DECL_NAME (decl), decl);
1525           else if (TREE_CODE (decl) == OVERLOAD)
1526             pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1527           else
1528             my_friendly_abort (0);
1529         }
1530     }
1531
1532   /* Remove declarations for any `for' variables from inner scopes
1533      that we kept around.  */
1534   for (link = current_binding_level->dead_vars_from_for;
1535        link; link = TREE_CHAIN (link))
1536     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1537
1538   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
1539   for (link = current_binding_level->type_shadowed;
1540        link; link = TREE_CHAIN (link))
1541     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1542
1543   /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
1544   for (link = current_binding_level->shadowed_labels;
1545        link;
1546        link = TREE_CHAIN (link))
1547     pop_label (TREE_VALUE (link), TREE_PURPOSE (link));
1548
1549   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1550      list if a `using' declaration put them there.  The debugging
1551      back-ends won't understand OVERLOAD, so we remove them here.
1552      Because the BLOCK_VARS are (temporarily) shared with
1553      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1554      popped all the bindings.  */
1555   if (block)
1556     {
1557       tree* d;
1558
1559       for (d = &BLOCK_VARS (block); *d; )
1560         {
1561           if (TREE_CODE (*d) == TREE_LIST)
1562             *d = TREE_CHAIN (*d);
1563           else
1564             d = &TREE_CHAIN (*d);
1565         }
1566     }
1567
1568   /* If the level being exited is the top level of a function,
1569      check over all the labels.  */
1570   if (functionbody)
1571     {
1572       /* Since this is the top level block of a function, the vars are
1573          the function's parameters.  Don't leave them in the BLOCK
1574          because they are found in the FUNCTION_DECL instead.  */
1575       BLOCK_VARS (block) = 0;
1576       pop_labels (block);
1577     }
1578
1579   tmp = current_binding_level->keep;
1580
1581   pop_binding_level ();
1582   if (functionbody)
1583     DECL_INITIAL (current_function_decl) = block;
1584   else if (block)
1585     {
1586       if (!block_previously_created)
1587         current_binding_level->blocks
1588           = chainon (current_binding_level->blocks, block);
1589     }
1590   /* If we did not make a block for the level just exited,
1591      any blocks made for inner levels
1592      (since they cannot be recorded as subblocks in that level)
1593      must be carried forward so they will later become subblocks
1594      of something else.  */
1595   else if (subblocks)
1596     current_binding_level->blocks
1597       = chainon (current_binding_level->blocks, subblocks);
1598
1599   /* Each and every BLOCK node created here in `poplevel' is important
1600      (e.g. for proper debugging information) so if we created one
1601      earlier, mark it as "used".  */
1602   if (block)
1603     TREE_USED (block) = 1;
1604
1605   /* Take care of compiler's internal binding structures.  */
1606   if (tmp == 2)
1607     {
1608       tree scope_stmts;
1609
1610       scope_stmts
1611         = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1612       if (block)
1613         {
1614           SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1615           SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1616         }
1617
1618       block = poplevel (keep, reverse, functionbody);
1619     }
1620
1621   return block;
1622 }
1623
1624 /* Delete the node BLOCK from the current binding level.
1625    This is used for the block inside a stmt expr ({...})
1626    so that the block can be reinserted where appropriate.  */
1627
1628 void
1629 delete_block (block)
1630      tree block;
1631 {
1632   tree t;
1633   if (current_binding_level->blocks == block)
1634     current_binding_level->blocks = TREE_CHAIN (block);
1635   for (t = current_binding_level->blocks; t;)
1636     {
1637       if (TREE_CHAIN (t) == block)
1638         TREE_CHAIN (t) = TREE_CHAIN (block);
1639       else
1640         t = TREE_CHAIN (t);
1641     }
1642   TREE_CHAIN (block) = NULL_TREE;
1643   /* Clear TREE_USED which is always set by poplevel.
1644      The flag is set again if insert_block is called.  */
1645   TREE_USED (block) = 0;
1646 }
1647
1648 /* Insert BLOCK at the end of the list of subblocks of the
1649    current binding level.  This is used when a BIND_EXPR is expanded,
1650    to handle the BLOCK node inside the BIND_EXPR.  */
1651
1652 void
1653 insert_block (block)
1654      tree block;
1655 {
1656   TREE_USED (block) = 1;
1657   current_binding_level->blocks
1658     = chainon (current_binding_level->blocks, block);
1659 }
1660
1661 /* Set the BLOCK node for the innermost scope
1662    (the one we are currently in).  */
1663
1664 void
1665 set_block (block)
1666     register tree block;
1667 {
1668   current_binding_level->this_block = block;
1669 }
1670
1671 /* Do a pushlevel for class declarations.  */
1672
1673 void
1674 pushlevel_class ()
1675 {
1676   register struct binding_level *newlevel;
1677
1678   /* Reuse or create a struct for this binding level.  */
1679 #if defined(DEBUG_CP_BINDING_LEVELS)
1680   if (0)
1681 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1682   if (free_binding_level)
1683 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1684     {
1685       newlevel = free_binding_level;
1686       free_binding_level = free_binding_level->level_chain;
1687     }
1688   else
1689     newlevel = make_binding_level ();
1690
1691 #if defined(DEBUG_CP_BINDING_LEVELS)
1692   is_class_level = 1;
1693 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1694
1695   push_binding_level (newlevel, 0, 0);
1696
1697   class_binding_level = current_binding_level;
1698   class_binding_level->parm_flag = 2;
1699   class_binding_level->this_class = current_class_type;
1700 }
1701
1702 /* ...and a poplevel for class declarations.  */
1703
1704 void
1705 poplevel_class ()
1706 {
1707   register struct binding_level *level = class_binding_level;
1708   tree shadowed;
1709
1710   my_friendly_assert (level != 0, 354);
1711
1712   /* If we're leaving a toplevel class, don't bother to do the setting
1713      of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1714      shouldn't even be used when current_class_type isn't set, and second,
1715      if we don't touch it here, we're able to use the cache effect if the
1716      next time we're entering a class scope, it is the same class.  */
1717   if (current_class_depth != 1)
1718     {
1719       struct binding_level* b;
1720
1721       /* Clear out our IDENTIFIER_CLASS_VALUEs.  */
1722       for (shadowed = level->class_shadowed;
1723            shadowed;
1724            shadowed = TREE_CHAIN (shadowed))
1725         IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1726
1727       /* Find the next enclosing class, and recreate
1728          IDENTIFIER_CLASS_VALUEs appropriate for that class.  */
1729       b = level->level_chain;
1730       while (b && b->parm_flag != 2)
1731         b = b->level_chain;
1732
1733       if (b)
1734         for (shadowed = b->class_shadowed;
1735              shadowed;
1736              shadowed = TREE_CHAIN (shadowed))
1737           {
1738             tree t;
1739
1740             t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1741             while (t && BINDING_LEVEL (t) != b)
1742               t = TREE_CHAIN (t);
1743
1744             if (t)
1745               IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1746                 = BINDING_VALUE (t);
1747           }
1748     }
1749   else
1750     /* Remember to save what IDENTIFIER's were bound in this scope so we
1751        can recover from cache misses.  */
1752     {
1753       previous_class_type = current_class_type;
1754       previous_class_values = class_binding_level->class_shadowed;
1755     }
1756   for (shadowed = level->type_shadowed;
1757        shadowed;
1758        shadowed = TREE_CHAIN (shadowed))
1759     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1760
1761   /* Remove the bindings for all of the class-level declarations.  */
1762   for (shadowed = level->class_shadowed;
1763        shadowed;
1764        shadowed = TREE_CHAIN (shadowed))
1765     pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1766
1767   GNU_xref_end_scope ((HOST_WIDE_INT) class_binding_level,
1768                       (HOST_WIDE_INT) class_binding_level->level_chain,
1769                       class_binding_level->parm_flag,
1770                       class_binding_level->keep);
1771
1772   /* Now, pop out of the binding level which we created up in the
1773      `pushlevel_class' routine.  */
1774 #if defined(DEBUG_CP_BINDING_LEVELS)
1775   is_class_level = 1;
1776 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1777
1778   pop_binding_level ();
1779 }
1780
1781 /* We are entering the scope of a class.  Clear IDENTIFIER_CLASS_VALUE
1782    for any names in enclosing classes.  */
1783
1784 void
1785 clear_identifier_class_values ()
1786 {
1787   tree t;
1788
1789   if (!class_binding_level)
1790     return;
1791
1792   for (t = class_binding_level->class_shadowed;
1793        t;
1794        t = TREE_CHAIN (t))
1795     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1796 }
1797
1798 /* Returns non-zero if T is a virtual function table.  */
1799
1800 int
1801 vtable_decl_p (t, data)
1802      tree t;
1803      void *data ATTRIBUTE_UNUSED;
1804 {
1805   return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1806 }
1807
1808 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1809    functions.  */
1810
1811 int
1812 vtype_decl_p (t, data)
1813      tree t;
1814      void *data ATTRIBUTE_UNUSED;
1815 {
1816   return (TREE_CODE (t) == TYPE_DECL
1817           && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE
1818           && TYPE_POLYMORPHIC_P (TREE_TYPE (t)));
1819 }
1820
1821 /* Return the declarations that are members of the namespace NS.  */
1822
1823 tree
1824 cp_namespace_decls (ns)
1825      tree ns;
1826 {
1827   return NAMESPACE_LEVEL (ns)->names;
1828 }
1829
1830 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1831    itself, calling F for each.  The DATA is passed to F as well.  */
1832
1833 static int
1834 walk_namespaces_r (namespace, f, data)
1835      tree namespace;
1836      walk_namespaces_fn f;
1837      void *data;
1838 {
1839   tree current;
1840   int result = 0;
1841
1842   result |= (*f) (namespace, data);
1843
1844   for (current = cp_namespace_decls (namespace);
1845        current;
1846        current = TREE_CHAIN (current))
1847     {
1848       if (TREE_CODE (current) != NAMESPACE_DECL
1849           || DECL_NAMESPACE_ALIAS (current))
1850         continue;
1851       if (!DECL_LANG_SPECIFIC (current))
1852         {
1853           /* Hmm. std. */
1854           my_friendly_assert (current == std_node, 393);
1855           continue;
1856         }
1857
1858       /* We found a namespace.  */
1859       result |= walk_namespaces_r (current, f, data);
1860     }
1861
1862   return result;
1863 }
1864
1865 /* Walk all the namespaces, calling F for each.  The DATA is passed to
1866    F as well.  */
1867
1868 int
1869 walk_namespaces (f, data)
1870      walk_namespaces_fn f;
1871      void *data;
1872 {
1873   return walk_namespaces_r (global_namespace, f, data);
1874 }
1875
1876 struct walk_globals_data {
1877   walk_globals_pred p;
1878   walk_globals_fn f;
1879   void *data;
1880 };
1881
1882 /* Walk the global declarations in NAMESPACE.  Whenever one is found
1883    for which P returns non-zero, call F with its address.  If any call
1884    to F returns a non-zero value, return a non-zero value.  */
1885
1886 static int
1887 walk_globals_r (namespace, data)
1888      tree namespace;
1889      void *data;
1890 {
1891   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1892   walk_globals_pred p = wgd->p;
1893   walk_globals_fn f = wgd->f;
1894   void *d = wgd->data;
1895   tree *t;
1896   int result = 0;
1897
1898   t = &NAMESPACE_LEVEL (namespace)->names;
1899
1900   while (*t)
1901     {
1902       tree glbl = *t;
1903
1904       if ((*p) (glbl, d))
1905         result |= (*f) (t, d);
1906
1907       /* If F changed *T, then *T still points at the next item to
1908          examine.  */
1909       if (*t == glbl)
1910         t = &TREE_CHAIN (*t);
1911     }
1912
1913   return result;
1914 }
1915
1916 /* Walk the global declarations.  Whenever one is found for which P
1917    returns non-zero, call F with its address.  If any call to F
1918    returns a non-zero value, return a non-zero value.  */
1919
1920 int
1921 walk_globals (p, f, data)
1922      walk_globals_pred p;
1923      walk_globals_fn f;
1924      void *data;
1925 {
1926   struct walk_globals_data wgd;
1927   wgd.p = p;
1928   wgd.f = f;
1929   wgd.data = data;
1930
1931   return walk_namespaces (walk_globals_r, &wgd);
1932 }
1933
1934 /* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
1935    DATA is non-NULL, this is the last time we will call
1936    wrapup_global_declarations for this NAMESPACE.  */
1937
1938 int
1939 wrapup_globals_for_namespace (namespace, data)
1940      tree namespace;
1941      void *data;
1942 {
1943   tree globals = cp_namespace_decls (namespace);
1944   int len = list_length (globals);
1945   tree *vec = (tree *) alloca (sizeof (tree) * len);
1946   int i;
1947   int result;
1948   tree decl;
1949   int last_time = (data != 0);
1950
1951   if (last_time && namespace == global_namespace)
1952     /* Let compile_file handle the global namespace.  */
1953     return 0;
1954
1955   /* Process the decls in reverse order--earliest first.
1956      Put them into VEC from back to front, then take out from front.  */
1957
1958   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1959     {
1960       /* Pretend we've output an unused static variable.  This ensures
1961          that the toplevel __FUNCTION__ etc won't be emitted, unless
1962          needed. */
1963       if (TREE_CODE (decl) == VAR_DECL && DECL_ARTIFICIAL (decl)
1964           && !TREE_PUBLIC (decl) && !TREE_USED (decl))
1965         {
1966           TREE_ASM_WRITTEN (decl) = 1;
1967           DECL_IGNORED_P (decl) = 1;
1968         }
1969       vec[len - i - 1] = decl;
1970     }
1971
1972   if (last_time)
1973     {
1974       check_global_declarations (vec, len);
1975       return 0;
1976     }
1977
1978   /* Temporarily mark vtables as external.  That prevents
1979      wrapup_global_declarations from writing them out; we must process
1980      them ourselves in finish_vtable_vardecl.  */
1981   for (i = 0; i < len; ++i)
1982     if (vtable_decl_p (vec[i], /*data=*/0) && !DECL_EXTERNAL (vec[i]))
1983       {
1984         DECL_NOT_REALLY_EXTERN (vec[i]) = 1;
1985         DECL_EXTERNAL (vec[i]) = 1;
1986       }
1987
1988   /* Write out any globals that need to be output.  */
1989   result = wrapup_global_declarations (vec, len);
1990
1991   /* Undo the hack to DECL_EXTERNAL above.  */
1992   for (i = 0; i < len; ++i)
1993     if (vtable_decl_p (vec[i], /*data=*/0)
1994         && DECL_NOT_REALLY_EXTERN (vec[i]))
1995       {
1996         DECL_NOT_REALLY_EXTERN (vec[i]) = 0;
1997         DECL_EXTERNAL (vec[i]) = 0;
1998       }
1999
2000   return result;
2001 }
2002
2003 \f
2004 /* Mark ARG (which is really a struct binding_level **) for GC.  */
2005
2006 static void
2007 mark_binding_level (arg)
2008      void *arg;
2009 {
2010   struct binding_level *lvl = *(struct binding_level **)arg;
2011
2012   for (; lvl; lvl = lvl->level_chain)
2013     {
2014       ggc_mark_tree (lvl->names);
2015       ggc_mark_tree (lvl->tags);
2016       ggc_mark_tree (lvl->usings);
2017       ggc_mark_tree (lvl->using_directives);
2018       ggc_mark_tree (lvl->class_shadowed);
2019       ggc_mark_tree (lvl->type_shadowed);
2020       ggc_mark_tree (lvl->shadowed_labels);
2021       ggc_mark_tree (lvl->blocks);
2022       ggc_mark_tree (lvl->this_block);
2023       ggc_mark_tree (lvl->this_class);
2024       ggc_mark_tree (lvl->incomplete);
2025       ggc_mark_tree (lvl->dead_vars_from_for);
2026     }
2027 }
2028
2029 static void
2030 mark_named_label_lists (labs, uses)
2031      void *labs;
2032      void *uses;
2033 {
2034   struct named_label_list *l = *(struct named_label_list **)labs;
2035   struct named_label_use_list *u = *(struct named_label_use_list **)uses;
2036
2037   for (; l; l = l->next)
2038     {
2039       ggc_mark (l);
2040       mark_binding_level (l->binding_level);
2041       ggc_mark_tree (l->old_value);
2042       ggc_mark_tree (l->label_decl);
2043       ggc_mark_tree (l->bad_decls);
2044     }
2045
2046   for (; u; u = u->next)
2047     ggc_mark (u);
2048 }
2049 \f
2050 /* For debugging.  */
2051 static int no_print_functions = 0;
2052 static int no_print_builtins = 0;
2053
2054 void
2055 print_binding_level (lvl)
2056      struct binding_level *lvl;
2057 {
2058   tree t;
2059   int i = 0, len;
2060   fprintf (stderr, " blocks=");
2061   fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
2062   fprintf (stderr, " n_incomplete=%d parm_flag=%d keep=%d",
2063            list_length (lvl->incomplete), lvl->parm_flag, lvl->keep);
2064   if (lvl->tag_transparent)
2065     fprintf (stderr, " tag-transparent");
2066   if (lvl->more_cleanups_ok)
2067     fprintf (stderr, " more-cleanups-ok");
2068   if (lvl->have_cleanups)
2069     fprintf (stderr, " have-cleanups");
2070   fprintf (stderr, "\n");
2071   if (lvl->names)
2072     {
2073       fprintf (stderr, " names:\t");
2074       /* We can probably fit 3 names to a line?  */
2075       for (t = lvl->names; t; t = TREE_CHAIN (t))
2076         {
2077           if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
2078             continue;
2079           if (no_print_builtins
2080               && (TREE_CODE (t) == TYPE_DECL)
2081               && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
2082             continue;
2083
2084           /* Function decls tend to have longer names.  */
2085           if (TREE_CODE (t) == FUNCTION_DECL)
2086             len = 3;
2087           else
2088             len = 2;
2089           i += len;
2090           if (i > 6)
2091             {
2092               fprintf (stderr, "\n\t");
2093               i = len;
2094             }
2095           print_node_brief (stderr, "", t, 0);
2096           if (t == error_mark_node)
2097             break;
2098         }
2099       if (i)
2100         fprintf (stderr, "\n");
2101     }
2102   if (lvl->tags)
2103     {
2104       fprintf (stderr, " tags:\t");
2105       i = 0;
2106       for (t = lvl->tags; t; t = TREE_CHAIN (t))
2107         {
2108           if (TREE_PURPOSE (t) == NULL_TREE)
2109             len = 3;
2110           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2111             len = 2;
2112           else
2113             len = 4;
2114           i += len;
2115           if (i > 5)
2116             {
2117               fprintf (stderr, "\n\t");
2118               i = len;
2119             }
2120           if (TREE_PURPOSE (t) == NULL_TREE)
2121             {
2122               print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
2123               fprintf (stderr, ">");
2124             }
2125           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2126             print_node_brief (stderr, "", TREE_VALUE (t), 0);
2127           else
2128             {
2129               print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
2130               print_node_brief (stderr, "", TREE_VALUE (t), 0);
2131               fprintf (stderr, ">");
2132             }
2133         }
2134       if (i)
2135         fprintf (stderr, "\n");
2136     }
2137   if (lvl->class_shadowed)
2138     {
2139       fprintf (stderr, " class-shadowed:");
2140       for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
2141         {
2142           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2143         }
2144       fprintf (stderr, "\n");
2145     }
2146   if (lvl->type_shadowed)
2147     {
2148       fprintf (stderr, " type-shadowed:");
2149       for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
2150         {
2151           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2152         }
2153       fprintf (stderr, "\n");
2154     }
2155 }
2156
2157 void
2158 print_other_binding_stack (stack)
2159      struct binding_level *stack;
2160 {
2161   struct binding_level *level;
2162   for (level = stack; level != global_binding_level; level = level->level_chain)
2163     {
2164       fprintf (stderr, "binding level ");
2165       fprintf (stderr, HOST_PTR_PRINTF, level);
2166       fprintf (stderr, "\n");
2167       print_binding_level (level);
2168     }
2169 }
2170
2171 void
2172 print_binding_stack ()
2173 {
2174   struct binding_level *b;
2175   fprintf (stderr, "current_binding_level=");
2176   fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
2177   fprintf (stderr, "\nclass_binding_level=");
2178   fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
2179   fprintf (stderr, "\nglobal_binding_level=");
2180   fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
2181   fprintf (stderr, "\n");
2182   if (class_binding_level)
2183     {
2184       for (b = class_binding_level; b; b = b->level_chain)
2185         if (b == current_binding_level)
2186           break;
2187       if (b)
2188         b = class_binding_level;
2189       else
2190         b = current_binding_level;
2191     }
2192   else
2193     b = current_binding_level;
2194   print_other_binding_stack (b);
2195   fprintf (stderr, "global:\n");
2196   print_binding_level (global_binding_level);
2197 }
2198
2199 /* Namespace binding access routines: The namespace_bindings field of
2200    the identifier is polymorphic, with three possible values:
2201    NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2202    indicating the BINDING_VALUE of global_namespace. */
2203
2204 /* Check whether the a binding for the name to scope is known.
2205    Assumes that the bindings of the name are already a list
2206    of bindings. Returns the binding found, or NULL_TREE. */
2207
2208 static tree
2209 find_binding (name, scope)
2210      tree name;
2211      tree scope;
2212 {
2213   tree iter, prev = NULL_TREE;
2214
2215   scope = ORIGINAL_NAMESPACE (scope);
2216
2217   for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2218        iter = TREE_CHAIN (iter))
2219     {
2220       my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2221       if (BINDING_SCOPE (iter) == scope)
2222         {
2223           /* Move binding found to the front of the list, so
2224              subsequent lookups will find it faster. */
2225           if (prev)
2226             {
2227               TREE_CHAIN (prev) = TREE_CHAIN (iter);
2228               TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2229               IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2230             }
2231           return iter;
2232         }
2233       prev = iter;
2234     }
2235   return NULL_TREE;
2236 }
2237
2238 /* Always returns a binding for name in scope. If the
2239    namespace_bindings is not a list, convert it to one first.
2240    If no binding is found, make a new one. */
2241
2242 tree
2243 binding_for_name (name, scope)
2244      tree name;
2245      tree scope;
2246 {
2247   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2248   tree result;
2249
2250   scope = ORIGINAL_NAMESPACE (scope);
2251
2252   if (b && TREE_CODE (b) != CPLUS_BINDING)
2253     {
2254       /* Get rid of optimization for global scope. */
2255       IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2256       BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2257       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2258     }
2259   if (b && (result = find_binding (name, scope)))
2260     return result;
2261   /* Not found, make a new one. */
2262   result = make_node (CPLUS_BINDING);
2263   TREE_CHAIN (result) = b;
2264   IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2265   BINDING_SCOPE (result) = scope;
2266   BINDING_TYPE (result) = NULL_TREE;
2267   BINDING_VALUE (result) = NULL_TREE;
2268   return result;
2269 }
2270
2271 /* Return the binding value for name in scope, considering that
2272    namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2273
2274 tree
2275 namespace_binding (name, scope)
2276      tree name;
2277      tree scope;
2278 {
2279   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2280   if (b == NULL_TREE)
2281     return NULL_TREE;
2282   if (scope == NULL_TREE)
2283     scope = global_namespace;
2284   if (TREE_CODE (b) != CPLUS_BINDING)
2285     return (scope == global_namespace) ? b : NULL_TREE;
2286   name = find_binding (name,scope);
2287   if (name == NULL_TREE)
2288     return name;
2289   return BINDING_VALUE (name);
2290 }
2291
2292 /* Set the binding value for name in scope. If modifying the binding
2293    of global_namespace is attempted, try to optimize it. */
2294
2295 void
2296 set_namespace_binding (name, scope, val)
2297      tree name;
2298      tree scope;
2299      tree val;
2300 {
2301   tree b;
2302
2303   if (scope == NULL_TREE)
2304     scope = global_namespace;
2305
2306   if (scope == global_namespace)
2307     {
2308       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2309       if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2310         {
2311           IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2312           return;
2313         }
2314     }
2315   b = binding_for_name (name, scope);
2316   BINDING_VALUE (b) = val;
2317 }
2318
2319 /* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
2320    select a name that is unique to this compilation unit.  */
2321
2322 void
2323 push_namespace (name)
2324      tree name;
2325 {
2326   tree d = NULL_TREE;
2327   int need_new = 1;
2328   int implicit_use = 0;
2329   int global = 0;
2330   if (!global_namespace)
2331     {
2332       /* This must be ::. */
2333       my_friendly_assert (name == get_identifier ("::"), 377);
2334       global = 1;
2335     }
2336   else if (!name)
2337     {
2338       /* The name of anonymous namespace is unique for the translation
2339          unit.  */
2340       if (!anonymous_namespace_name)
2341         anonymous_namespace_name = get_file_function_name ('N');
2342       name = anonymous_namespace_name;
2343       d = IDENTIFIER_NAMESPACE_VALUE (name);
2344       if (d)
2345         /* Reopening anonymous namespace.  */
2346         need_new = 0;
2347       implicit_use = 1;
2348     }
2349   else if (current_namespace == global_namespace
2350            && name == DECL_NAME (std_node))
2351     {
2352       in_std++;
2353       return;
2354     }
2355   else
2356     {
2357       /* Check whether this is an extended namespace definition. */
2358       d = IDENTIFIER_NAMESPACE_VALUE (name);
2359       if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2360         {
2361           need_new = 0;
2362           if (DECL_NAMESPACE_ALIAS (d))
2363             {
2364               cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
2365                         d, DECL_NAMESPACE_ALIAS (d));
2366               d = DECL_NAMESPACE_ALIAS (d);
2367             }
2368         }
2369     }
2370
2371   if (need_new)
2372     {
2373       /* Make a new namespace, binding the name to it. */
2374       d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2375       /* The global namespace is not pushed, and the global binding
2376          level is set elsewhere.  */
2377       if (!global)
2378         {
2379           DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
2380           d = pushdecl (d);
2381           pushlevel (0);
2382           declare_namespace_level ();
2383           NAMESPACE_LEVEL (d) = current_binding_level;
2384         }
2385     }
2386   else
2387     resume_binding_level (NAMESPACE_LEVEL (d));
2388
2389   if (implicit_use)
2390     do_using_directive (d);
2391   /* Enter the name space. */
2392   current_namespace = d;
2393 }
2394
2395 /* Pop from the scope of the current namespace.  */
2396
2397 void
2398 pop_namespace ()
2399 {
2400   if (current_namespace == global_namespace)
2401     {
2402       my_friendly_assert (in_std>0, 980421);
2403       in_std--;
2404       return;
2405     }
2406   current_namespace = CP_DECL_CONTEXT (current_namespace);
2407   /* The binding level is not popped, as it might be re-opened later.  */
2408   suspend_binding_level ();
2409 }
2410
2411 /* Push into the scope of the namespace NS, even if it is deeply
2412    nested within another namespace.  */
2413
2414 void
2415 push_nested_namespace (ns)
2416      tree ns;
2417 {
2418   if (ns == global_namespace)
2419     push_to_top_level ();
2420   else
2421     {
2422       push_nested_namespace (CP_DECL_CONTEXT (ns));
2423       push_namespace (DECL_NAME (ns));
2424     }
2425 }
2426
2427 /* Pop back from the scope of the namespace NS, which was previously
2428    entered with push_nested_namespace.  */
2429
2430 void
2431 pop_nested_namespace (ns)
2432      tree ns;
2433 {
2434   while (ns != global_namespace)
2435     {
2436       pop_namespace ();
2437       ns = CP_DECL_CONTEXT (ns);
2438     }
2439
2440   pop_from_top_level ();
2441 }
2442
2443 \f
2444 /* Subroutines for reverting temporarily to top-level for instantiation
2445    of templates and such.  We actually need to clear out the class- and
2446    local-value slots of all identifiers, so that only the global values
2447    are at all visible.  Simply setting current_binding_level to the global
2448    scope isn't enough, because more binding levels may be pushed.  */
2449 struct saved_scope *scope_chain;
2450
2451 /* Mark ST for GC.  */
2452
2453 static void
2454 mark_stmt_tree (st)
2455      struct stmt_tree *st;
2456 {
2457   ggc_mark_tree (st->x_last_stmt);
2458   ggc_mark_tree (st->x_last_expr_type);
2459 }
2460
2461 /* Mark ARG (which is really a struct saved_scope **) for GC.  */
2462
2463 static void
2464 mark_saved_scope (arg)
2465      void *arg;
2466 {
2467   struct saved_scope *t = *(struct saved_scope **)arg;
2468   while (t)
2469     {
2470       mark_binding_level (&t->class_bindings);
2471       ggc_mark_tree (t->old_bindings);
2472       ggc_mark_tree (t->old_namespace);
2473       ggc_mark_tree (t->class_name);
2474       ggc_mark_tree (t->class_type);
2475       ggc_mark_tree (t->access_specifier);
2476       ggc_mark_tree (t->function_decl);
2477       if (t->lang_base)
2478         ggc_mark_tree_varray (t->lang_base);
2479       ggc_mark_tree (t->lang_name);
2480       ggc_mark_tree (t->x_function_parms);
2481       ggc_mark_tree (t->template_parms);
2482       ggc_mark_tree (t->x_previous_class_type);
2483       ggc_mark_tree (t->x_previous_class_values);
2484       ggc_mark_tree (t->x_saved_tree);
2485       ggc_mark_tree (t->incomplete);
2486       ggc_mark_tree (t->lookups);
2487
2488       mark_stmt_tree (&t->x_stmt_tree);
2489       mark_binding_level (&t->bindings);
2490       t = t->prev;
2491     }
2492 }
2493
2494 static tree
2495 store_bindings (names, old_bindings)
2496      tree names, old_bindings;
2497 {
2498   tree t;
2499   for (t = names; t; t = TREE_CHAIN (t))
2500     {
2501       tree binding, t1, id;
2502
2503       if (TREE_CODE (t) == TREE_LIST)
2504         id = TREE_PURPOSE (t);
2505       else
2506         id = DECL_NAME (t);
2507
2508       if (!id
2509           /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2510              we have no IDENTIFIER_BINDING if we have left the class
2511              scope, but cached the class-level declarations.  */
2512           || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2513         continue;
2514
2515       for (t1 = old_bindings; t1; t1 = TREE_CHAIN (t1))
2516         if (TREE_VEC_ELT (t1, 0) == id)
2517           goto skip_it;
2518
2519       binding = make_tree_vec (4);
2520
2521       if (id)
2522         {
2523           my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2524           TREE_VEC_ELT (binding, 0) = id;
2525           TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2526           TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2527           TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2528           IDENTIFIER_BINDING (id) = NULL_TREE;
2529           IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2530         }
2531       TREE_CHAIN (binding) = old_bindings;
2532       old_bindings = binding;
2533     skip_it:
2534       ;
2535     }
2536   return old_bindings;
2537 }
2538
2539 void
2540 maybe_push_to_top_level (pseudo)
2541      int pseudo;
2542 {
2543   struct saved_scope *s;
2544   struct binding_level *b;
2545   tree old_bindings;
2546   int need_pop;
2547
2548   s = (struct saved_scope *) xcalloc (1, sizeof (struct saved_scope));
2549
2550   b = scope_chain ? current_binding_level : 0;
2551
2552   /* If we're in the middle of some function, save our state.  */
2553   if (cfun)
2554     {
2555       need_pop = 1;
2556       push_function_context_to (NULL_TREE);
2557     }
2558   else
2559     need_pop = 0;
2560
2561   old_bindings = NULL_TREE;
2562   if (scope_chain && previous_class_type)
2563     old_bindings = store_bindings (previous_class_values, old_bindings);
2564
2565   /* Have to include global_binding_level, because class-level decls
2566      aren't listed anywhere useful.  */
2567   for (; b; b = b->level_chain)
2568     {
2569       tree t;
2570
2571       /* Template IDs are inserted into the global level. If they were
2572          inserted into namespace level, finish_file wouldn't find them
2573          when doing pending instantiations. Therefore, don't stop at
2574          namespace level, but continue until :: .  */
2575       if (b == global_binding_level || (pseudo && b->template_parms_p))
2576         break;
2577
2578       old_bindings = store_bindings (b->names, old_bindings);
2579       /* We also need to check class_shadowed to save class-level type
2580          bindings, since pushclass doesn't fill in b->names.  */
2581       if (b->parm_flag == 2)
2582         old_bindings = store_bindings (b->class_shadowed, old_bindings);
2583
2584       /* Unwind type-value slots back to top level.  */
2585       for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2586         SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2587     }
2588   s->prev = scope_chain;
2589   s->old_bindings = old_bindings;
2590   s->bindings = b;
2591   s->need_pop_function_context = need_pop;
2592   s->function_decl = current_function_decl;
2593
2594   scope_chain = s;
2595   current_function_decl = NULL_TREE;
2596   VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2597   current_lang_stack = &VARRAY_TREE (current_lang_base, 0);
2598   current_lang_name = lang_name_cplusplus;
2599   current_namespace = global_namespace;
2600 }
2601
2602 void
2603 push_to_top_level ()
2604 {
2605   maybe_push_to_top_level (0);
2606 }
2607
2608 void
2609 pop_from_top_level ()
2610 {
2611   struct saved_scope *s = scope_chain;
2612   tree t;
2613
2614   /* Clear out class-level bindings cache.  */
2615   if (previous_class_type)
2616     invalidate_class_lookup_cache ();
2617
2618   VARRAY_FREE (current_lang_base);
2619
2620   scope_chain = s->prev;
2621   for (t = s->old_bindings; t; t = TREE_CHAIN (t))
2622     {
2623       tree id = TREE_VEC_ELT (t, 0);
2624       if (id)
2625         {
2626           SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2627           IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2628           IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2629         }
2630     }
2631
2632   /* If we were in the middle of compiling a function, restore our
2633      state.  */
2634   if (s->need_pop_function_context)
2635     pop_function_context_from (NULL_TREE);
2636   current_function_decl = s->function_decl;
2637
2638   free (s);
2639 }
2640 \f
2641 /* Push a definition of struct, union or enum tag "name".
2642    into binding_level "b".   "type" should be the type node,
2643    We assume that the tag "name" is not already defined.
2644
2645    Note that the definition may really be just a forward reference.
2646    In that case, the TYPE_SIZE will be a NULL_TREE.
2647
2648    C++ gratuitously puts all these tags in the name space.  */
2649
2650 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2651    record the shadowed value for this binding contour.  TYPE is
2652    the type that ID maps to.  */
2653
2654 static void
2655 set_identifier_type_value_with_scope (id, type, b)
2656      tree id;
2657      tree type;
2658      struct binding_level *b;
2659 {
2660   if (!b->namespace_p)
2661     {
2662       /* Shadow the marker, not the real thing, so that the marker
2663          gets restored later. */
2664       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2665       b->type_shadowed
2666         = tree_cons (id, old_type_value, b->type_shadowed);
2667     }
2668   else
2669     {
2670       tree binding = binding_for_name (id, current_namespace);
2671       BINDING_TYPE (binding) = type;
2672       /* Store marker instead of real type. */
2673       type = global_type_node;
2674     }
2675   SET_IDENTIFIER_TYPE_VALUE (id, type);
2676 }
2677
2678 /* As set_identifier_type_value_with_scope, but using current_binding_level.  */
2679
2680 void
2681 set_identifier_type_value (id, type)
2682      tree id;
2683      tree type;
2684 {
2685   set_identifier_type_value_with_scope (id, type, current_binding_level);
2686 }
2687
2688 /* Return the type associated with id. */
2689
2690 tree
2691 identifier_type_value (id)
2692      tree id;
2693 {
2694   /* There is no type with that name, anywhere. */
2695   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2696     return NULL_TREE;
2697   /* This is not the type marker, but the real thing. */
2698   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2699     return REAL_IDENTIFIER_TYPE_VALUE (id);
2700   /* Have to search for it. It must be on the global level, now.
2701      Ask lookup_name not to return non-types. */
2702   id = lookup_name_real (id, 2, 1, 0);
2703   if (id)
2704     return TREE_TYPE (id);
2705   return NULL_TREE;
2706 }
2707
2708 /* Pop off extraneous binding levels left over due to syntax errors.
2709
2710    We don't pop past namespaces, as they might be valid.  */
2711
2712 void
2713 pop_everything ()
2714 {
2715 #ifdef DEBUG_CP_BINDING_LEVELS
2716   fprintf (stderr, "XXX entering pop_everything ()\n");
2717 #endif
2718   while (!toplevel_bindings_p ())
2719     {
2720       if (current_binding_level->parm_flag == 2)
2721         pop_nested_class ();
2722       else
2723         poplevel (0, 0, 0);
2724     }
2725 #ifdef DEBUG_CP_BINDING_LEVELS
2726   fprintf (stderr, "XXX leaving pop_everything ()\n");
2727 #endif
2728 }
2729
2730 /* The type TYPE is being declared.  If it is a class template, or a
2731    specialization of a class template, do any processing required and
2732    perform error-checking.  If IS_FRIEND is non-zero, this TYPE is
2733    being declared a friend.  B is the binding level at which this TYPE
2734    should be bound.
2735
2736    Returns the TYPE_DECL for TYPE, which may have been altered by this
2737    processing.  */
2738
2739 static tree
2740 maybe_process_template_type_declaration (type, globalize, b)
2741      tree type;
2742      int globalize;
2743      struct binding_level* b;
2744 {
2745   tree decl = TYPE_NAME (type);
2746
2747   if (processing_template_parmlist)
2748     /* You can't declare a new template type in a template parameter
2749        list.  But, you can declare a non-template type:
2750
2751          template <class A*> struct S;
2752
2753        is a forward-declaration of `A'.  */
2754     ;
2755   else
2756     {
2757       maybe_check_template_type (type);
2758
2759       my_friendly_assert (IS_AGGR_TYPE (type)
2760                           || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2761
2762
2763       if (processing_template_decl)
2764         {
2765           /* This may change after the call to
2766              push_template_decl_real, but we want the original value.  */
2767           tree name = DECL_NAME (decl);
2768
2769           decl = push_template_decl_real (decl, globalize);
2770           /* If the current binding level is the binding level for the
2771              template parameters (see the comment in
2772              begin_template_parm_list) and the enclosing level is a class
2773              scope, and we're not looking at a friend, push the
2774              declaration of the member class into the class scope.  In the
2775              friend case, push_template_decl will already have put the
2776              friend into global scope, if appropriate.  */
2777           if (TREE_CODE (type) != ENUMERAL_TYPE
2778               && !globalize && b->template_parms_p
2779               && b->level_chain->parm_flag == 2)
2780             {
2781               finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2782               /* Put this tag on the list of tags for the class, since
2783                  that won't happen below because B is not the class
2784                  binding level, but is instead the pseudo-global level.  */
2785               b->level_chain->tags =
2786                 tree_cons (name, type, b->level_chain->tags);
2787               if (!COMPLETE_TYPE_P (current_class_type))
2788                 CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2789             }
2790         }
2791     }
2792
2793   return decl;
2794 }
2795
2796 /* In C++, you don't have to write `struct S' to refer to `S'; you
2797    can just use `S'.  We accomplish this by creating a TYPE_DECL as
2798    if the user had written `typedef struct S S'.  Create and return
2799    the TYPE_DECL for TYPE.  */
2800
2801 tree
2802 create_implicit_typedef (name, type)
2803      tree name;
2804      tree type;
2805 {
2806   tree decl;
2807
2808   decl = build_decl (TYPE_DECL, name, type);
2809   DECL_ARTIFICIAL (decl) = 1;
2810   /* There are other implicit type declarations, like the one *within*
2811      a class that allows you to write `S::S'.  We must distinguish
2812      amongst these.  */
2813   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2814   TYPE_NAME (type) = decl;
2815
2816   return decl;
2817 }
2818
2819 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2820    Normally put it into the inner-most non-tag-transparent scope,
2821    but if GLOBALIZE is true, put it in the inner-most non-class scope.
2822    The latter is needed for implicit declarations.  */
2823
2824 void
2825 pushtag (name, type, globalize)
2826      tree name, type;
2827      int globalize;
2828 {
2829   register struct binding_level *b;
2830
2831   b = current_binding_level;
2832   while (b->tag_transparent
2833          || (globalize && b->parm_flag == 2))
2834     b = b->level_chain;
2835
2836   b->tags = tree_cons (name, type, b->tags);
2837
2838   if (name)
2839     {
2840       /* Do C++ gratuitous typedefing.  */
2841       if (IDENTIFIER_TYPE_VALUE (name) != type)
2842         {
2843           register tree d = NULL_TREE;
2844           int in_class = 0;
2845           tree context = TYPE_CONTEXT (type);
2846
2847           if (! context)
2848             {
2849               tree cs = current_scope ();
2850
2851               if (! globalize)
2852                 context = cs;
2853               else if (cs != NULL_TREE && TYPE_P (cs))
2854                 /* When declaring a friend class of a local class, we want
2855                    to inject the newly named class into the scope
2856                    containing the local class, not the namespace scope.  */
2857                 context = decl_function_context (get_type_decl (cs));
2858             }
2859           if (!context)
2860             context = current_namespace;
2861
2862           if ((b->template_parms_p && b->level_chain->parm_flag == 2)
2863               || b->parm_flag == 2)
2864             in_class = 1;
2865
2866           if (current_lang_name == lang_name_java)
2867             TYPE_FOR_JAVA (type) = 1;
2868
2869           d = create_implicit_typedef (name, type);
2870           DECL_CONTEXT (d) = FROB_CONTEXT (context);
2871           if (! in_class)
2872             set_identifier_type_value_with_scope (name, type, b);
2873
2874           d = maybe_process_template_type_declaration (type,
2875                                                        globalize, b);
2876
2877           if (b->parm_flag == 2)
2878             {
2879               if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2880                 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2881                    class.  But if it's a member template class, we
2882                    want the TEMPLATE_DECL, not the TYPE_DECL, so this
2883                    is done later.  */
2884                 finish_member_declaration (d);
2885               else
2886                 pushdecl_class_level (d);
2887             }
2888           else
2889             d = pushdecl_with_scope (d, b);
2890
2891           if (ANON_AGGRNAME_P (name))
2892             DECL_IGNORED_P (d) = 1;
2893
2894           TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2895           DECL_ASSEMBLER_NAME (d) = DECL_NAME (d);
2896
2897           /* If this is a local class, keep track of it.  We need this
2898              information for name-mangling, and so that it is possible to find
2899              all function definitions in a translation unit in a convenient
2900              way.  (It's otherwise tricky to find a member function definition
2901              it's only pointed to from within a local class.)  */
2902           if (TYPE_CONTEXT (type)
2903               && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL
2904               && !processing_template_decl)
2905             VARRAY_PUSH_TREE (local_classes, type);
2906
2907           if (!uses_template_parms (type))
2908             {
2909               if (flag_new_abi)
2910                 DECL_ASSEMBLER_NAME (d) = mangle_type (type);
2911               else
2912                 DECL_ASSEMBLER_NAME (d)
2913                   = get_identifier (build_overload_name (type, 1, 1));
2914             }
2915         }
2916       if (b->parm_flag == 2)
2917         {
2918           if (!COMPLETE_TYPE_P (current_class_type))
2919             CLASSTYPE_TAGS (current_class_type) = b->tags;
2920         }
2921     }
2922
2923   if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2924     /* Use the canonical TYPE_DECL for this node.  */
2925     TYPE_STUB_DECL (type) = TYPE_NAME (type);
2926   else
2927     {
2928       /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2929          will be the tagged type we just added to the current
2930          binding level.  This fake NULL-named TYPE_DECL node helps
2931          dwarfout.c to know when it needs to output a
2932          representation of a tagged type, and it also gives us a
2933          convenient place to record the "scope start" address for
2934          the tagged type.  */
2935
2936       tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2937       TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2938     }
2939 }
2940
2941 /* Counter used to create anonymous type names.  */
2942
2943 static int anon_cnt = 0;
2944
2945 /* Return an IDENTIFIER which can be used as a name for
2946    anonymous structs and unions.  */
2947
2948 tree
2949 make_anon_name ()
2950 {
2951   char buf[32];
2952
2953   sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2954   return get_identifier (buf);
2955 }
2956
2957 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2958    This keeps dbxout from getting confused.  */
2959
2960 void
2961 clear_anon_tags ()
2962 {
2963   register struct binding_level *b;
2964   register tree tags;
2965   static int last_cnt = 0;
2966
2967   /* Fast out if no new anon names were declared.  */
2968   if (last_cnt == anon_cnt)
2969     return;
2970
2971   b = current_binding_level;
2972   while (b->tag_transparent)
2973     b = b->level_chain;
2974   tags = b->tags;
2975   while (tags)
2976     {
2977       /* A NULL purpose means we have already processed all tags
2978          from here to the end of the list.  */
2979       if (TREE_PURPOSE (tags) == NULL_TREE)
2980         break;
2981       if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2982         TREE_PURPOSE (tags) = NULL_TREE;
2983       tags = TREE_CHAIN (tags);
2984     }
2985   last_cnt = anon_cnt;
2986 }
2987 \f
2988 /* Subroutine of duplicate_decls: return truthvalue of whether
2989    or not types of these decls match.
2990
2991    For C++, we must compare the parameter list so that `int' can match
2992    `int&' in a parameter position, but `int&' is not confused with
2993    `const int&'.  */
2994
2995 int
2996 decls_match (newdecl, olddecl)
2997      tree newdecl, olddecl;
2998 {
2999   int types_match;
3000
3001   if (newdecl == olddecl)
3002     return 1;
3003
3004   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
3005     /* If the two DECLs are not even the same kind of thing, we're not
3006        interested in their types.  */
3007     return 0;
3008
3009   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3010     {
3011       tree f1 = TREE_TYPE (newdecl);
3012       tree f2 = TREE_TYPE (olddecl);
3013       tree p1 = TYPE_ARG_TYPES (f1);
3014       tree p2 = TYPE_ARG_TYPES (f2);
3015
3016       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
3017           && ! (DECL_EXTERN_C_P (newdecl)
3018                 && DECL_EXTERN_C_P (olddecl)))
3019         return 0;
3020
3021       if (TREE_CODE (f1) != TREE_CODE (f2))
3022         return 0;
3023
3024       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
3025         {
3026           if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
3027               && (DECL_BUILT_IN (olddecl)
3028 #ifndef NO_IMPLICIT_EXTERN_C
3029                   || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
3030                   || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
3031 #endif
3032               ))
3033             {
3034               types_match = self_promoting_args_p (p1);
3035               if (p1 == void_list_node)
3036                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
3037             }
3038 #ifndef NO_IMPLICIT_EXTERN_C
3039           else if (p1 == NULL_TREE
3040                    && (DECL_EXTERN_C_P (olddecl)
3041                        && DECL_IN_SYSTEM_HEADER (olddecl)
3042                        && !DECL_CLASS_SCOPE_P (olddecl))
3043                    && (DECL_EXTERN_C_P (newdecl)
3044                        && DECL_IN_SYSTEM_HEADER (newdecl)
3045                        && !DECL_CLASS_SCOPE_P (newdecl)))
3046             {
3047               types_match = self_promoting_args_p (p2);
3048               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
3049             }
3050 #endif
3051           else
3052             types_match = compparms (p1, p2);
3053         }
3054       else
3055         types_match = 0;
3056     }
3057   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3058     {
3059       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3060                                 DECL_TEMPLATE_PARMS (olddecl)))
3061         return 0;
3062
3063       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
3064           != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
3065         return 0;
3066
3067       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3068         types_match = 1;
3069       else
3070         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
3071                                    DECL_TEMPLATE_RESULT (newdecl));
3072     }
3073   else
3074     {
3075       if (TREE_TYPE (newdecl) == error_mark_node)
3076         types_match = TREE_TYPE (olddecl) == error_mark_node;
3077       else if (TREE_TYPE (olddecl) == NULL_TREE)
3078         types_match = TREE_TYPE (newdecl) == NULL_TREE;
3079       else if (TREE_TYPE (newdecl) == NULL_TREE)
3080         types_match = 0;
3081       else
3082         types_match = comptypes (TREE_TYPE (newdecl),
3083                                  TREE_TYPE (olddecl),
3084                                  COMPARE_REDECLARATION);
3085     }
3086
3087   return types_match;
3088 }
3089
3090 /* If NEWDECL is `static' and an `extern' was seen previously,
3091    warn about it.  OLDDECL is the previous declaration.
3092
3093    Note that this does not apply to the C++ case of declaring
3094    a variable `extern const' and then later `const'.
3095
3096    Don't complain about built-in functions, since they are beyond
3097    the user's control.  */
3098
3099 static void
3100 warn_extern_redeclared_static (newdecl, olddecl)
3101      tree newdecl, olddecl;
3102 {
3103   static const char *explicit_extern_static_warning
3104     = "`%D' was declared `extern' and later `static'";
3105   static const char *implicit_extern_static_warning
3106     = "`%D' was declared implicitly `extern' and later `static'";
3107
3108   tree name;
3109
3110   if (TREE_CODE (newdecl) == TYPE_DECL
3111       || TREE_CODE (newdecl) == TEMPLATE_DECL
3112       || TREE_CODE (newdecl) == CONST_DECL)
3113     return;
3114
3115   /* Don't get confused by static member functions; that's a different
3116      use of `static'.  */
3117   if (TREE_CODE (newdecl) == FUNCTION_DECL
3118       && DECL_STATIC_FUNCTION_P (newdecl))
3119     return;
3120
3121   /* If the old declaration was `static', or the new one isn't, then
3122      then everything is OK.  */
3123   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
3124     return;
3125
3126   /* It's OK to declare a builtin function as `static'.  */
3127   if (TREE_CODE (olddecl) == FUNCTION_DECL
3128       && DECL_ARTIFICIAL (olddecl))
3129     return;
3130
3131   name = DECL_ASSEMBLER_NAME (newdecl);
3132   cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
3133               ? implicit_extern_static_warning
3134               : explicit_extern_static_warning, newdecl);
3135   cp_pedwarn_at ("previous declaration of `%D'", olddecl);
3136 }
3137
3138 /* Handle when a new declaration NEWDECL has the same name as an old
3139    one OLDDECL in the same binding contour.  Prints an error message
3140    if appropriate.
3141
3142    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
3143    Otherwise, return 0.  */
3144
3145 int
3146 duplicate_decls (newdecl, olddecl)
3147      tree newdecl, olddecl;
3148 {
3149   unsigned olddecl_uid = DECL_UID (olddecl);
3150   int olddecl_friend = 0, types_match = 0;
3151   int new_defines_function = 0;
3152
3153   if (newdecl == olddecl)
3154     return 1;
3155
3156   types_match = decls_match (newdecl, olddecl);
3157
3158   /* If either the type of the new decl or the type of the old decl is an
3159      error_mark_node, then that implies that we have already issued an
3160      error (earlier) for some bogus type specification, and in that case,
3161      it is rather pointless to harass the user with yet more error message
3162      about the same declaration, so just pretend the types match here.  */
3163   if (TREE_TYPE (newdecl) == error_mark_node
3164       || TREE_TYPE (olddecl) == error_mark_node)
3165     types_match = 1;
3166
3167   /* Check for redeclaration and other discrepancies. */
3168   if (TREE_CODE (olddecl) == FUNCTION_DECL
3169       && DECL_ARTIFICIAL (olddecl))
3170     {
3171       if (TREE_CODE (newdecl) != FUNCTION_DECL)
3172         {
3173           /* If you declare a built-in or predefined function name as static,
3174              the old definition is overridden, but optionally warn this was a
3175              bad choice of name.  */
3176           if (! TREE_PUBLIC (newdecl))
3177             {
3178               if (warn_shadow)
3179                 cp_warning ("shadowing %s function `%#D'",
3180                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3181                             olddecl);
3182               /* Discard the old built-in function.  */
3183               return 0;
3184             }
3185           /* If the built-in is not ansi, then programs can override
3186              it even globally without an error.  */
3187           else if (! DECL_BUILT_IN (olddecl))
3188             cp_warning ("library function `%#D' redeclared as non-function `%#D'",
3189                         olddecl, newdecl);
3190           else
3191             {
3192               cp_error ("declaration of `%#D'", newdecl);
3193               cp_error ("conflicts with built-in declaration `%#D'",
3194                         olddecl);
3195             }
3196           return 0;
3197         }
3198       else if (!types_match)
3199         {
3200           if ((DECL_EXTERN_C_P (newdecl)
3201                && DECL_EXTERN_C_P (olddecl))
3202               || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3203                             TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3204             {
3205               /* A near match; override the builtin.  */
3206
3207               if (TREE_PUBLIC (newdecl))
3208                 {
3209                   cp_warning ("new declaration `%#D'", newdecl);
3210                   cp_warning ("ambiguates built-in declaration `%#D'",
3211                               olddecl);
3212                 }
3213               else if (warn_shadow)
3214                 cp_warning ("shadowing %s function `%#D'",
3215                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3216                             olddecl);
3217             }
3218           else
3219             /* Discard the old built-in function.  */
3220             return 0;
3221         }
3222
3223       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3224         {
3225           /* If a builtin function is redeclared as `static', merge
3226              the declarations, but make the original one static.  */
3227           DECL_THIS_STATIC (olddecl) = 1;
3228           TREE_PUBLIC (olddecl) = 0;
3229
3230           /* Make the old declaration consistent with the new one so
3231              that all remnants of the builtin-ness of this function
3232              will be banished.  */
3233           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3234           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3235           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3236           SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (newdecl),
3237                                        newdecl);
3238         }
3239     }
3240   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3241     {
3242       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3243            && TREE_CODE (newdecl) != TYPE_DECL
3244            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3245                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3246           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3247               && TREE_CODE (olddecl) != TYPE_DECL
3248               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3249                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3250                         == TYPE_DECL))))
3251         {
3252           /* We do nothing special here, because C++ does such nasty
3253              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
3254              get shadowed, and know that if we need to find a TYPE_DECL
3255              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3256              slot of the identifier.  */
3257           return 0;
3258         }
3259
3260       if ((TREE_CODE (newdecl) == FUNCTION_DECL
3261            && DECL_FUNCTION_TEMPLATE_P (olddecl))
3262           || (TREE_CODE (olddecl) == FUNCTION_DECL
3263               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3264         return 0;
3265
3266       cp_error ("`%#D' redeclared as different kind of symbol", newdecl);
3267       if (TREE_CODE (olddecl) == TREE_LIST)
3268         olddecl = TREE_VALUE (olddecl);
3269       cp_error_at ("previous declaration of `%#D'", olddecl);
3270
3271       /* New decl is completely inconsistent with the old one =>
3272          tell caller to replace the old one.  */
3273
3274       return 0;
3275     }
3276   else if (!types_match)
3277     {
3278       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
3279         /* These are certainly not duplicate declarations; they're
3280            from different scopes.  */
3281         return 0;
3282
3283       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3284         {
3285           /* The name of a class template may not be declared to refer to
3286              any other template, class, function, object, namespace, value,
3287              or type in the same scope.  */
3288           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3289               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3290             {
3291               cp_error ("declaration of template `%#D'", newdecl);
3292               cp_error_at ("conflicts with previous declaration `%#D'",
3293                            olddecl);
3294             }
3295           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3296                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3297                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3298                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3299                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3300                                            DECL_TEMPLATE_PARMS (olddecl)))
3301             {
3302               cp_error ("new declaration `%#D'", newdecl);
3303               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3304             }
3305           return 0;
3306         }
3307       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3308         {
3309           if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
3310             {
3311               cp_error ("declaration of C function `%#D' conflicts with",
3312                         newdecl);
3313               cp_error_at ("previous declaration `%#D' here", olddecl);
3314             }
3315           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3316                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3317             {
3318               cp_error ("new declaration `%#D'", newdecl);
3319               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3320             }
3321           else
3322             return 0;
3323         }
3324
3325       /* Already complained about this, so don't do so again.  */
3326       else if (current_class_type == NULL_TREE
3327           || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3328         {
3329           cp_error ("conflicting types for `%#D'", newdecl);
3330           cp_error_at ("previous declaration as `%#D'", olddecl);
3331         }
3332     }
3333   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3334             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3335                  && (!DECL_TEMPLATE_INFO (newdecl)
3336                      || (DECL_TI_TEMPLATE (newdecl)
3337                          != DECL_TI_TEMPLATE (olddecl))))
3338                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3339                     && (!DECL_TEMPLATE_INFO (olddecl)
3340                         || (DECL_TI_TEMPLATE (olddecl)
3341                             != DECL_TI_TEMPLATE (newdecl))))))
3342     /* It's OK to have a template specialization and a non-template
3343        with the same type, or to have specializations of two
3344        different templates with the same type.  Note that if one is a
3345        specialization, and the other is an instantiation of the same
3346        template, that we do not exit at this point.  That situation
3347        can occur if we instantiate a template class, and then
3348        specialize one of its methods.  This situation is legal, but
3349        the declarations must be merged in the usual way.  */
3350     return 0;
3351   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3352            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3353                 && !DECL_USE_TEMPLATE (newdecl))
3354                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3355                    && !DECL_USE_TEMPLATE (olddecl))))
3356     /* One of the declarations is a template instantiation, and the
3357        other is not a template at all.  That's OK.  */
3358     return 0;
3359   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3360            && DECL_NAMESPACE_ALIAS (newdecl)
3361            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3362     /* Redeclaration of namespace alias, ignore it. */
3363     return 1;
3364   else
3365     {
3366       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3367       if (errmsg)
3368         {
3369           cp_error (errmsg, newdecl);
3370           if (DECL_NAME (olddecl) != NULL_TREE)
3371             cp_error_at ((DECL_INITIAL (olddecl)
3372                           && namespace_bindings_p ())
3373                          ? "`%#D' previously defined here"
3374                          : "`%#D' previously declared here", olddecl);
3375         }
3376       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3377                && DECL_INITIAL (olddecl) != NULL_TREE
3378                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3379                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3380         {
3381           /* Prototype decl follows defn w/o prototype.  */
3382           cp_warning_at ("prototype for `%#D'", newdecl);
3383           cp_warning_at ("follows non-prototype definition here", olddecl);
3384         }
3385       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3386                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3387         {
3388           /* extern "C" int foo ();
3389              int foo () { bar (); }
3390              is OK.  */
3391           if (current_lang_stack
3392               == &VARRAY_TREE (current_lang_base, 0))
3393             DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3394           else
3395             {
3396               cp_error_at ("previous declaration of `%#D' with %L linkage",
3397                            olddecl, DECL_LANGUAGE (olddecl));
3398               cp_error ("conflicts with new declaration with %L linkage",
3399                         DECL_LANGUAGE (newdecl));
3400             }
3401         }
3402
3403       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3404         ;
3405       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3406         {
3407           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3408           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3409           int i = 1;
3410
3411           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3412             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3413
3414           for (; t1 && t1 != void_list_node;
3415                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3416             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3417               {
3418                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3419                                            TREE_PURPOSE (t2)))
3420                   {
3421                     if (pedantic)
3422                       {
3423                         cp_pedwarn ("default argument given for parameter %d of `%#D'",
3424                                     i, newdecl);
3425                         cp_pedwarn_at ("after previous specification in `%#D'",
3426                                        olddecl);
3427                       }
3428                   }
3429                 else
3430                   {
3431                     cp_error ("default argument given for parameter %d of `%#D'",
3432                               i, newdecl);
3433                     cp_error_at ("after previous specification in `%#D'",
3434                                  olddecl);
3435                   }
3436               }
3437
3438           if (DECL_THIS_INLINE (newdecl) && ! DECL_THIS_INLINE (olddecl)
3439               && TREE_ADDRESSABLE (olddecl) && warn_inline)
3440             {
3441               cp_warning ("`%#D' was used before it was declared inline",
3442                           newdecl);
3443               cp_warning_at ("previous non-inline declaration here",
3444                              olddecl);
3445             }
3446         }
3447     }
3448
3449   /* If new decl is `static' and an `extern' was seen previously,
3450      warn about it.  */
3451   warn_extern_redeclared_static (newdecl, olddecl);
3452
3453   /* We have committed to returning 1 at this point.  */
3454   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3455     {
3456       /* Now that functions must hold information normally held
3457          by field decls, there is extra work to do so that
3458          declaration information does not get destroyed during
3459          definition.  */
3460       if (DECL_VINDEX (olddecl))
3461         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3462       if (DECL_VIRTUAL_CONTEXT (olddecl))
3463         DECL_VIRTUAL_CONTEXT (newdecl) = DECL_VIRTUAL_CONTEXT (olddecl);
3464       if (DECL_CONTEXT (olddecl))
3465         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3466       if (DECL_PENDING_INLINE_INFO (newdecl) == (struct pending_inline *)0)
3467         DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3468       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3469       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3470       DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3471       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3472       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3473       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3474       DECL_LANG_SPECIFIC (newdecl)->u2 = DECL_LANG_SPECIFIC (olddecl)->u2;
3475       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3476
3477       /* Optionally warn about more than one declaration for the same
3478          name, but don't warn about a function declaration followed by a
3479          definition.  */
3480       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3481           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3482           /* Don't warn about extern decl followed by definition. */
3483           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3484           /* Don't warn about friends, let add_friend take care of it. */
3485           && ! DECL_FRIEND_P (newdecl))
3486         {
3487           cp_warning ("redundant redeclaration of `%D' in same scope", newdecl);
3488           cp_warning_at ("previous declaration of `%D'", olddecl);
3489         }
3490     }
3491
3492   /* Deal with C++: must preserve virtual function table size.  */
3493   if (TREE_CODE (olddecl) == TYPE_DECL)
3494     {
3495       register tree newtype = TREE_TYPE (newdecl);
3496       register tree oldtype = TREE_TYPE (olddecl);
3497
3498       if (newtype != error_mark_node && oldtype != error_mark_node
3499           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3500         {
3501           CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
3502           CLASSTYPE_FRIEND_CLASSES (newtype)
3503             = CLASSTYPE_FRIEND_CLASSES (oldtype);
3504         }
3505
3506       DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
3507     }
3508
3509   /* Copy all the DECL_... slots specified in the new decl
3510      except for any that we copy here from the old type.  */
3511   DECL_MACHINE_ATTRIBUTES (newdecl)
3512     = merge_machine_decl_attributes (olddecl, newdecl);
3513
3514   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3515     {
3516       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3517       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3518         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3519                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3520
3521       return 1;
3522     }
3523
3524   if (types_match)
3525     {
3526       /* Automatically handles default parameters.  */
3527       tree oldtype = TREE_TYPE (olddecl);
3528       tree newtype;
3529
3530       /* Merge the data types specified in the two decls.  */
3531       newtype = common_type (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3532
3533       /* If common_type produces a non-typedef type, just use the old type.  */
3534       if (TREE_CODE (newdecl) == TYPE_DECL
3535           && newtype == DECL_ORIGINAL_TYPE (newdecl))
3536         newtype = oldtype;
3537
3538       if (TREE_CODE (newdecl) == VAR_DECL)
3539         DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3540       /* Do this after calling `common_type' so that default
3541          parameters don't confuse us.  */
3542       else if (TREE_CODE (newdecl) == FUNCTION_DECL
3543           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3544               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3545         {
3546           TREE_TYPE (newdecl) = build_exception_variant (newtype,
3547                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3548           TREE_TYPE (olddecl) = build_exception_variant (newtype,
3549                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
3550
3551           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3552               && DECL_SOURCE_LINE (olddecl) != 0
3553               && flag_exceptions
3554               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3555                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3556             {
3557               cp_error ("declaration of `%F' throws different exceptions",
3558                         newdecl);
3559               cp_error_at ("than previous declaration `%F'", olddecl);
3560             }
3561         }
3562       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3563
3564       /* Lay the type out, unless already done.  */
3565       if (! same_type_p (newtype, oldtype)
3566           && TREE_TYPE (newdecl) != error_mark_node
3567           && !(processing_template_decl && uses_template_parms (newdecl)))
3568         layout_type (TREE_TYPE (newdecl));
3569
3570       if ((TREE_CODE (newdecl) == VAR_DECL
3571            || TREE_CODE (newdecl) == PARM_DECL
3572            || TREE_CODE (newdecl) == RESULT_DECL
3573            || TREE_CODE (newdecl) == FIELD_DECL
3574            || TREE_CODE (newdecl) == TYPE_DECL)
3575           && !(processing_template_decl && uses_template_parms (newdecl)))
3576         layout_decl (newdecl, 0);
3577
3578       /* Merge the type qualifiers.  */
3579       if (TREE_READONLY (newdecl))
3580         TREE_READONLY (olddecl) = 1;
3581       if (TREE_THIS_VOLATILE (newdecl))
3582         TREE_THIS_VOLATILE (olddecl) = 1;
3583
3584       /* Merge the initialization information.  */
3585       if (DECL_INITIAL (newdecl) == NULL_TREE
3586           && DECL_INITIAL (olddecl) != NULL_TREE)
3587         {
3588           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3589           DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
3590           DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
3591           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3592               && DECL_LANG_SPECIFIC (newdecl)
3593               && DECL_LANG_SPECIFIC (olddecl))
3594             DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3595         }
3596
3597       /* Merge the section attribute.
3598          We want to issue an error if the sections conflict but that must be
3599          done later in decl_attributes since we are called before attributes
3600          are assigned.  */
3601       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3602         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3603
3604       /* Keep the old rtl since we can safely use it.  */
3605       DECL_RTL (newdecl) = DECL_RTL (olddecl);
3606
3607       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3608         {
3609           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3610             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3611           DECL_NO_CHECK_MEMORY_USAGE (newdecl)
3612             |= DECL_NO_CHECK_MEMORY_USAGE (olddecl);
3613           DECL_NO_LIMIT_STACK (newdecl)
3614             |= DECL_NO_LIMIT_STACK (olddecl);
3615         }
3616     }
3617   /* If cannot merge, then use the new type and qualifiers,
3618      and don't preserve the old rtl.  */
3619   else
3620     {
3621       /* Clean out any memory we had of the old declaration.  */
3622       tree oldstatic = value_member (olddecl, static_aggregates);
3623       if (oldstatic)
3624         TREE_VALUE (oldstatic) = error_mark_node;
3625
3626       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3627       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3628       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3629       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3630     }
3631
3632   /* Merge the storage class information.  */
3633   DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
3634   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3635   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3636   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3637   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3638   if (! DECL_EXTERNAL (olddecl))
3639     DECL_EXTERNAL (newdecl) = 0;
3640
3641   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3642     {
3643       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3644       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3645       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3646       DECL_TEMPLATE_INSTANTIATED (newdecl)
3647         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3648       /* Don't really know how much of the language-specific
3649          values we should copy from old to new.  */
3650       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3651       DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
3652       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3653       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3654       olddecl_friend = DECL_FRIEND_P (olddecl);
3655
3656       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
3657       if (TREE_CODE (newdecl) == FUNCTION_DECL
3658           || DECL_FUNCTION_TEMPLATE_P (newdecl))
3659         DECL_BEFRIENDING_CLASSES (newdecl)
3660           = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3661                      DECL_BEFRIENDING_CLASSES (olddecl));
3662     }
3663
3664   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3665     {
3666       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3667           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3668         {
3669           /* If newdecl is not a specialization, then it is not a
3670              template-related function at all.  And that means that we
3671              shoud have exited above, returning 0.  */
3672           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3673                               0);
3674
3675           if (TREE_USED (olddecl))
3676             /* From [temp.expl.spec]:
3677
3678                If a template, a member template or the member of a class
3679                template is explicitly specialized then that
3680                specialization shall be declared before the first use of
3681                that specialization that would cause an implicit
3682                instantiation to take place, in every translation unit in
3683                which such a use occurs.  */
3684             cp_error ("explicit specialization of %D after first use",
3685                       olddecl);
3686
3687           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3688         }
3689       DECL_THIS_INLINE (newdecl) |= DECL_THIS_INLINE (olddecl);
3690
3691       /* If either decl says `inline', this fn is inline, unless its
3692          definition was passed already.  */
3693       if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3694         DECL_INLINE (olddecl) = 1;
3695       DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3696
3697       if (! types_match)
3698         {
3699           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3700           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3701           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3702         }
3703       if (! types_match || new_defines_function)
3704         {
3705           /* These need to be copied so that the names are available.
3706              Note that if the types do match, we'll preserve inline
3707              info and other bits, but if not, we won't.  */
3708           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3709           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3710         }
3711       if (new_defines_function)
3712         /* If defining a function declared with other language
3713            linkage, use the previously declared language linkage.  */
3714         DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3715       else if (types_match)
3716         {
3717           /* If redeclaring a builtin function, and not a definition,
3718              it stays built in.  */
3719           if (DECL_BUILT_IN (olddecl))
3720             {
3721               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3722               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3723               /* If we're keeping the built-in definition, keep the rtl,
3724                  regardless of declaration matches.  */
3725               DECL_RTL (newdecl) = DECL_RTL (olddecl);
3726             }
3727           else
3728             DECL_FRAME_SIZE (newdecl) = DECL_FRAME_SIZE (olddecl);
3729
3730           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3731           if ((DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl)))
3732             /* Previously saved insns go together with
3733                the function's previous definition.  */
3734             DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3735           /* Don't clear out the arguments if we're redefining a function.  */
3736           if (DECL_ARGUMENTS (olddecl))
3737             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3738         }
3739     }
3740
3741   if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3742     {
3743       NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3744     }
3745
3746   /* Now preserve various other info from the definition.  */
3747   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3748   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3749   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3750   DECL_ASSEMBLER_NAME (newdecl) = DECL_ASSEMBLER_NAME (olddecl);
3751
3752   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3753     {
3754       int function_size;
3755
3756       function_size = sizeof (struct tree_decl);
3757
3758       bcopy ((char *) newdecl + sizeof (struct tree_common),
3759              (char *) olddecl + sizeof (struct tree_common),
3760              function_size - sizeof (struct tree_common));
3761
3762       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3763         {
3764           /* If newdecl is a template instantiation, it is possible that
3765              the following sequence of events has occurred:
3766
3767              o A friend function was declared in a class template.  The
3768              class template was instantiated.
3769
3770              o The instantiation of the friend declaration was
3771              recorded on the instantiation list, and is newdecl.
3772
3773              o Later, however, instantiate_class_template called pushdecl
3774              on the newdecl to perform name injection.  But, pushdecl in
3775              turn called duplicate_decls when it discovered that another
3776              declaration of a global function with the same name already
3777              existed.
3778
3779              o Here, in duplicate_decls, we decided to clobber newdecl.
3780
3781              If we're going to do that, we'd better make sure that
3782              olddecl, and not newdecl, is on the list of
3783              instantiations so that if we try to do the instantiation
3784              again we won't get the clobbered declaration.  */
3785
3786           tree tmpl = DECL_TI_TEMPLATE (newdecl);
3787           tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3788
3789           for (; decls; decls = TREE_CHAIN (decls))
3790             if (TREE_VALUE (decls) == newdecl)
3791               TREE_VALUE (decls) = olddecl;
3792         }
3793     }
3794   else
3795     {
3796       bcopy ((char *) newdecl + sizeof (struct tree_common),
3797              (char *) olddecl + sizeof (struct tree_common),
3798              sizeof (struct tree_decl) - sizeof (struct tree_common)
3799              + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
3800     }
3801
3802   DECL_UID (olddecl) = olddecl_uid;
3803   if (olddecl_friend)
3804     DECL_FRIEND_P (olddecl) = 1;
3805
3806   /* NEWDECL contains the merged attribute lists.
3807      Update OLDDECL to be the same.  */
3808   DECL_MACHINE_ATTRIBUTES (olddecl) = DECL_MACHINE_ATTRIBUTES (newdecl);
3809
3810   return 1;
3811 }
3812
3813 /* Record a decl-node X as belonging to the current lexical scope.
3814    Check for errors (such as an incompatible declaration for the same
3815    name already seen in the same scope).
3816
3817    Returns either X or an old decl for the same name.
3818    If an old decl is returned, it may have been smashed
3819    to agree with what X says.  */
3820
3821 tree
3822 pushdecl (x)
3823      tree x;
3824 {
3825   register tree t;
3826   register tree name;
3827   int need_new_binding;
3828
3829   /* We shouldn't be calling pushdecl when we're generating RTL for a
3830      function that we already did semantic analysis on previously.  */
3831   my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3832                       19990913);
3833
3834   need_new_binding = 1;
3835
3836   if (DECL_TEMPLATE_PARM_P (x))
3837     /* Template parameters have no context; they are not X::T even
3838        when declared within a class or namespace.  */
3839     ;
3840   else
3841     {
3842       if (current_function_decl && x != current_function_decl
3843           /* A local declaration for a function doesn't constitute
3844              nesting.  */
3845           && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3846           /* A local declaration for an `extern' variable is in the
3847              scoped of the current namespace, not the current
3848              function.  */
3849           && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3850           && !DECL_CONTEXT (x))
3851         DECL_CONTEXT (x) = current_function_decl;
3852
3853       /* If this is the declaration for a namespace-scope function,
3854          but the declaration itself is in a local scope, mark the
3855          declaration.  */
3856       if (TREE_CODE (x) == FUNCTION_DECL
3857           && DECL_NAMESPACE_SCOPE_P (x)
3858           && current_function_decl
3859           && x != current_function_decl)
3860         DECL_LOCAL_FUNCTION_P (x) = 1;
3861     }
3862
3863   name = DECL_NAME (x);
3864   if (name)
3865     {
3866 #if 0
3867       /* Not needed...see below.  */
3868       char *file;
3869       int line;
3870 #endif
3871       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3872         name = TREE_OPERAND (name, 0);
3873
3874       /* Namespace-scoped variables are not found in the current level. */
3875       if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x))
3876         t = namespace_binding (name, DECL_CONTEXT (x));
3877       else
3878         t = lookup_name_current_level (name);
3879
3880       /* If we are declaring a function, and the result of name-lookup
3881          was an OVERLOAD, look for an overloaded instance that is
3882          actually the same as the function we are declaring.  (If
3883          there is one, we have to merge our declaration with the
3884          previous declaration.)  */
3885       if (t && TREE_CODE (t) == OVERLOAD)
3886         {
3887           tree match;
3888
3889           if (TREE_CODE (x) == FUNCTION_DECL)
3890             for (match = t; match; match = OVL_NEXT (match))
3891               {
3892                 if (DECL_ASSEMBLER_NAME (OVL_CURRENT (t))
3893                     == DECL_ASSEMBLER_NAME (x))
3894                   break;
3895               }
3896           else
3897             /* Just choose one.  */
3898             match = t;
3899
3900           if (match)
3901             t = OVL_CURRENT (match);
3902           else
3903             t = NULL_TREE;
3904         }
3905
3906       if (t == error_mark_node)
3907         {
3908           /* error_mark_node is 0 for a while during initialization!  */
3909           t = NULL_TREE;
3910           cp_error_at ("`%#D' used prior to declaration", x);
3911         }
3912       else if (t != NULL_TREE)
3913         {
3914           if (TREE_CODE (t) == PARM_DECL)
3915             {
3916               if (DECL_CONTEXT (t) == NULL_TREE)
3917                 fatal ("parse errors have confused me too much");
3918
3919               /* Check for duplicate params.  */
3920               if (duplicate_decls (x, t))
3921                 return t;
3922             }
3923           else if ((DECL_EXTERN_C_FUNCTION_P (x)
3924                     || DECL_FUNCTION_TEMPLATE_P (x))
3925                    && is_overloaded_fn (t))
3926             /* Don't do anything just yet. */;
3927           else if (t == wchar_decl_node)
3928             {
3929               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3930                 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x));
3931
3932               /* Throw away the redeclaration.  */
3933               return t;
3934             }
3935           else if (TREE_CODE (t) != TREE_CODE (x))
3936             {
3937               if (duplicate_decls (x, t))
3938                 return t;
3939             }
3940           else if (duplicate_decls (x, t))
3941             {
3942               if (TREE_CODE (t) == TYPE_DECL)
3943                 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3944               else if (TREE_CODE (t) == FUNCTION_DECL)
3945                 check_default_args (t);
3946
3947               return t;
3948             }
3949           else if (DECL_MAIN_P (x))
3950             {
3951               /* A redeclaration of main, but not a duplicate of the
3952                  previous one.
3953
3954                  [basic.start.main]
3955
3956                  This function shall not be overloaded.  */
3957               cp_error_at ("invalid redeclaration of `%D'", t);
3958               cp_error ("as `%D'", x);
3959               /* We don't try to push this declaration since that
3960                  causes a crash.  */
3961               return x;
3962             }
3963         }
3964
3965       check_template_shadow (x);
3966
3967       /* If this is a function conjured up by the backend, massage it
3968          so it looks friendly.  */
3969       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
3970         {
3971           retrofit_lang_decl (x);
3972           DECL_LANGUAGE (x) = lang_c;
3973         }
3974
3975       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
3976         {
3977           t = push_overloaded_decl (x, PUSH_LOCAL);
3978           if (t != x)
3979             return t;
3980           if (!namespace_bindings_p ())
3981             /* We do not need to create a binding for this name;
3982                push_overloaded_decl will have already done so if
3983                necessary.  */
3984             need_new_binding = 0;
3985         }
3986       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
3987         {
3988           t = push_overloaded_decl (x, PUSH_GLOBAL);
3989           if (t == x)
3990             add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
3991           return t;
3992         }
3993
3994       /* If declaring a type as a typedef, copy the type (unless we're
3995          at line 0), and install this TYPE_DECL as the new type's typedef
3996          name.  See the extensive comment in ../c-decl.c (pushdecl). */
3997       if (TREE_CODE (x) == TYPE_DECL)
3998         {
3999           tree type = TREE_TYPE (x);
4000           if (DECL_SOURCE_LINE (x) == 0)
4001             {
4002               if (TYPE_NAME (type) == 0)
4003                 TYPE_NAME (type) = x;
4004             }
4005           else if (type != error_mark_node && TYPE_NAME (type) != x
4006                    /* We don't want to copy the type when all we're
4007                       doing is making a TYPE_DECL for the purposes of
4008                       inlining.  */
4009                    && (!TYPE_NAME (type)
4010                        || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
4011             {
4012               DECL_ORIGINAL_TYPE (x) = type;
4013               type = build_type_copy (type);
4014               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
4015               TYPE_NAME (type) = x;
4016               TREE_TYPE (x) = type;
4017             }
4018
4019           if (type != error_mark_node
4020               && TYPE_NAME (type)
4021               && TYPE_IDENTIFIER (type))
4022             set_identifier_type_value_with_scope (DECL_NAME (x), type,
4023                                                   current_binding_level);
4024
4025         }
4026
4027       /* Multiple external decls of the same identifier ought to match.
4028
4029          We get warnings about inline functions where they are defined.
4030          We get warnings about other functions from push_overloaded_decl.
4031
4032          Avoid duplicate warnings where they are used.  */
4033       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
4034         {
4035           tree decl;
4036
4037           decl = IDENTIFIER_NAMESPACE_VALUE (name);
4038           if (decl && TREE_CODE (decl) == OVERLOAD)
4039             decl = OVL_FUNCTION (decl);
4040
4041           if (decl && decl != error_mark_node
4042               && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
4043               /* If different sort of thing, we already gave an error.  */
4044               && TREE_CODE (decl) == TREE_CODE (x)
4045               && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
4046             {
4047               cp_pedwarn ("type mismatch with previous external decl", x);
4048               cp_pedwarn_at ("previous external decl of `%#D'", decl);
4049             }
4050         }
4051
4052       /* This name is new in its binding level.
4053          Install the new declaration and return it.  */
4054       if (namespace_bindings_p ())
4055         {
4056           /* Install a global value.  */
4057
4058           /* If the first global decl has external linkage,
4059              warn if we later see static one.  */
4060           if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
4061             TREE_PUBLIC (name) = 1;
4062
4063           /* Bind the mangled name for the entity.  In the future, we
4064              should not need to do this; mangled names are an
4065              implementation detail of which the front-end should not
4066              need to be aware.  */
4067           if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
4068                 && t != NULL_TREE)
4069               /* For an ordinary function, we create a binding from
4070                  the mangled name (i.e., NAME) to the DECL.  But, for
4071                  an `extern "C"' function, the mangled name and the
4072                  ordinary name are the same so we need not do this.  */
4073               && !DECL_EXTERN_C_FUNCTION_P (x))
4074             {
4075               tree mangled_name;
4076
4077               if (TREE_CODE (x) == TYPE_DECL || TREE_CODE (x) == VAR_DECL
4078                   || TREE_CODE (x) == NAMESPACE_DECL)
4079                 mangled_name = name;
4080               else
4081                 mangled_name = DECL_ASSEMBLER_NAME (x);
4082
4083               if (TREE_CODE (x) == FUNCTION_DECL)
4084                 my_friendly_assert
4085                   ((IDENTIFIER_GLOBAL_VALUE (mangled_name) == NULL_TREE)
4086                   || (IDENTIFIER_GLOBAL_VALUE (mangled_name) == x), 378);
4087               SET_IDENTIFIER_NAMESPACE_VALUE (mangled_name, x);
4088             }
4089
4090           /* Don't forget if the function was used via an implicit decl.  */
4091           if (IDENTIFIER_IMPLICIT_DECL (name)
4092               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
4093             TREE_USED (x) = 1;
4094
4095           /* Don't forget if its address was taken in that way.  */
4096           if (IDENTIFIER_IMPLICIT_DECL (name)
4097               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
4098             TREE_ADDRESSABLE (x) = 1;
4099
4100           /* Warn about mismatches against previous implicit decl.  */
4101           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
4102               /* If this real decl matches the implicit, don't complain.  */
4103               && ! (TREE_CODE (x) == FUNCTION_DECL
4104                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
4105             cp_warning
4106               ("`%D' was previously implicitly declared to return `int'", x);
4107
4108           /* If new decl is `static' and an `extern' was seen previously,
4109              warn about it.  */
4110           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
4111             warn_extern_redeclared_static (x, t);
4112         }
4113       else
4114         {
4115           /* Here to install a non-global value.  */
4116           tree oldlocal = IDENTIFIER_VALUE (name);
4117           tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
4118
4119           if (need_new_binding)
4120             {
4121               push_local_binding (name, x, 0);
4122               /* Because push_local_binding will hook X on to the
4123                  current_binding_level's name list, we don't want to
4124                  do that again below.  */
4125               need_new_binding = 0;
4126             }
4127
4128           /* If this is a TYPE_DECL, push it into the type value slot.  */
4129           if (TREE_CODE (x) == TYPE_DECL)
4130             set_identifier_type_value_with_scope (name, TREE_TYPE (x),
4131                                                   current_binding_level);
4132
4133           /* Clear out any TYPE_DECL shadowed by a namespace so that
4134              we won't think this is a type.  The C struct hack doesn't
4135              go through namespaces.  */
4136           if (TREE_CODE (x) == NAMESPACE_DECL)
4137             set_identifier_type_value_with_scope (name, NULL_TREE,
4138                                                   current_binding_level);
4139
4140           if (oldlocal)
4141             {
4142               tree d = oldlocal;
4143
4144               while (oldlocal
4145                      && TREE_CODE (oldlocal) == VAR_DECL
4146                      && DECL_DEAD_FOR_LOCAL (oldlocal))
4147                 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
4148
4149               if (oldlocal == NULL_TREE)
4150                 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
4151             }
4152
4153           /* If this is an extern function declaration, see if we
4154              have a global definition or declaration for the function.  */
4155           if (oldlocal == NULL_TREE
4156               && DECL_EXTERNAL (x)
4157               && oldglobal != NULL_TREE
4158               && TREE_CODE (x) == FUNCTION_DECL
4159               && TREE_CODE (oldglobal) == FUNCTION_DECL)
4160             {
4161               /* We have one.  Their types must agree.  */
4162               if (decls_match (x, oldglobal))
4163                 /* OK */;
4164               else
4165                 {
4166                   cp_warning ("extern declaration of `%#D' doesn't match", x);
4167                   cp_warning_at ("global declaration `%#D'", oldglobal);
4168                 }
4169             }
4170           /* If we have a local external declaration,
4171              and no file-scope declaration has yet been seen,
4172              then if we later have a file-scope decl it must not be static.  */
4173           if (oldlocal == NULL_TREE
4174               && oldglobal == NULL_TREE
4175               && DECL_EXTERNAL (x)
4176               && TREE_PUBLIC (x))
4177             TREE_PUBLIC (name) = 1;
4178
4179           /* Warn if shadowing an argument at the top level of the body.  */
4180           if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
4181               /* Inline decls shadow nothing.  */
4182               && !DECL_FROM_INLINE (x)
4183               && TREE_CODE (oldlocal) == PARM_DECL
4184               /* Don't complain if it's from an enclosing function.  */
4185               && DECL_CONTEXT (oldlocal) == current_function_decl
4186               && TREE_CODE (x) != PARM_DECL)
4187             {
4188               /* Go to where the parms should be and see if we
4189                  find them there.  */
4190               struct binding_level *b = current_binding_level->level_chain;
4191
4192               if (cleanup_label)
4193                 b = b->level_chain;
4194
4195               /* ARM $8.3 */
4196               if (b->parm_flag == 1)
4197                 cp_error ("declaration of `%#D' shadows a parameter", name);
4198             }
4199
4200           /* Maybe warn if shadowing something else.  */
4201           if (warn_shadow && !DECL_EXTERNAL (x)
4202               /* Inline decls shadow nothing.  */
4203               && !DECL_FROM_INLINE (x)
4204               /* No shadow warnings for internally generated vars.  */
4205               && ! DECL_ARTIFICIAL (x)
4206               /* No shadow warnings for vars made for inlining.  */
4207               && ! DECL_FROM_INLINE (x))
4208             {
4209               if (oldlocal != NULL_TREE && TREE_CODE (oldlocal) == PARM_DECL)
4210                 warning ("declaration of `%s' shadows a parameter",
4211                         IDENTIFIER_POINTER (name));
4212               else if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4213                        && current_class_ptr
4214                        && !TREE_STATIC (name))
4215                 warning ("declaration of `%s' shadows a member of `this'",
4216                         IDENTIFIER_POINTER (name));
4217               else if (oldlocal != NULL_TREE)
4218                 warning ("declaration of `%s' shadows previous local",
4219                         IDENTIFIER_POINTER (name));
4220               else if (oldglobal != NULL_TREE)
4221                 /* XXX shadow warnings in outer-more namespaces */
4222                 warning ("declaration of `%s' shadows global declaration",
4223                         IDENTIFIER_POINTER (name));
4224             }
4225         }
4226
4227       if (TREE_CODE (x) == FUNCTION_DECL)
4228         check_default_args (x);
4229
4230       /* Keep count of variables in this level with incomplete type.  */
4231       if (TREE_CODE (x) == VAR_DECL
4232           && TREE_TYPE (x) != error_mark_node
4233           && ((!COMPLETE_TYPE_P (TREE_TYPE (x))
4234                && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
4235               /* RTTI TD entries are created while defining the type_info.  */
4236               || (TYPE_LANG_SPECIFIC (TREE_TYPE (x))
4237                   && TYPE_BEING_DEFINED (TREE_TYPE (x)))))
4238         {
4239           if (namespace_bindings_p ())
4240             namespace_scope_incomplete
4241               = tree_cons (NULL_TREE, x, namespace_scope_incomplete);
4242           else
4243             current_binding_level->incomplete
4244               = tree_cons (NULL_TREE, x, current_binding_level->incomplete);
4245         }
4246     }
4247
4248   if (need_new_binding)
4249     add_decl_to_level (x,
4250                        DECL_NAMESPACE_SCOPE_P (x)
4251                        ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4252                        : current_binding_level);
4253
4254   return x;
4255 }
4256
4257 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
4258    caller to set DECL_CONTEXT properly.  */
4259
4260 static tree
4261 pushdecl_with_scope (x, level)
4262      tree x;
4263      struct binding_level *level;
4264 {
4265   register struct binding_level *b;
4266   tree function_decl = current_function_decl;
4267
4268   current_function_decl = NULL_TREE;
4269   if (level->parm_flag == 2)
4270     {
4271       b = class_binding_level;
4272       class_binding_level = level;
4273       pushdecl_class_level (x);
4274       class_binding_level = b;
4275     }
4276   else
4277     {
4278       b = current_binding_level;
4279       current_binding_level = level;
4280       x = pushdecl (x);
4281       current_binding_level = b;
4282     }
4283   current_function_decl = function_decl;
4284   return x;
4285 }
4286
4287 /* Like pushdecl, only it places X in the current namespace,
4288    if appropriate.  */
4289
4290 tree
4291 pushdecl_namespace_level (x)
4292      tree x;
4293 {
4294   register struct binding_level *b = current_binding_level;
4295   register tree t;
4296
4297   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4298
4299   /* Now, the type_shadowed stack may screw us.  Munge it so it does
4300      what we want.  */
4301   if (TREE_CODE (x) == TYPE_DECL)
4302     {
4303       tree name = DECL_NAME (x);
4304       tree newval;
4305       tree *ptr = (tree *)0;
4306       for (; b != global_binding_level; b = b->level_chain)
4307         {
4308           tree shadowed = b->type_shadowed;
4309           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4310             if (TREE_PURPOSE (shadowed) == name)
4311               {
4312                 ptr = &TREE_VALUE (shadowed);
4313                 /* Can't break out of the loop here because sometimes
4314                    a binding level will have duplicate bindings for
4315                    PT names.  It's gross, but I haven't time to fix it.  */
4316               }
4317         }
4318       newval = TREE_TYPE (x);
4319       if (ptr == (tree *)0)
4320         {
4321           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
4322              up here if this is changed to an assertion.  --KR  */
4323           SET_IDENTIFIER_TYPE_VALUE (name, newval);
4324         }
4325       else
4326         {
4327           *ptr = newval;
4328         }
4329     }
4330   return t;
4331 }
4332
4333 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4334    if appropriate.  */
4335
4336 tree
4337 pushdecl_top_level (x)
4338      tree x;
4339 {
4340   push_to_top_level ();
4341   x = pushdecl_namespace_level (x);
4342   pop_from_top_level ();
4343   return x;
4344 }
4345
4346 /* Make the declaration of X appear in CLASS scope.  */
4347
4348 void
4349 pushdecl_class_level (x)
4350      tree x;
4351 {
4352   /* Don't use DECL_ASSEMBLER_NAME here!  Everything that looks in class
4353      scope looks for the pre-mangled name.  */
4354   register tree name;
4355
4356   if (TREE_CODE (x) == OVERLOAD)
4357     x = OVL_CURRENT (x);
4358   name = DECL_NAME (x);
4359
4360   if (name)
4361     {
4362       push_class_level_binding (name, x);
4363       if (TREE_CODE (x) == TYPE_DECL)
4364         set_identifier_type_value (name, TREE_TYPE (x));
4365     }
4366   else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4367     {
4368       tree f;
4369
4370       for (f = TYPE_FIELDS (TREE_TYPE (x));
4371            f;
4372            f = TREE_CHAIN (f))
4373         pushdecl_class_level (f);
4374     }
4375 }
4376
4377 /* Enter DECL into the symbol table, if that's appropriate.  Returns
4378    DECL, or a modified version thereof.  */
4379
4380 tree
4381 maybe_push_decl (decl)
4382      tree decl;
4383 {
4384   tree type = TREE_TYPE (decl);
4385
4386   /* Add this decl to the current binding level, but not if it comes
4387      from another scope, e.g. a static member variable.  TEM may equal
4388      DECL or it may be a previous decl of the same name.  */
4389   if (decl == error_mark_node
4390       || (TREE_CODE (decl) != PARM_DECL
4391           && DECL_CONTEXT (decl) != NULL_TREE
4392           /* Definitions of namespace members outside their namespace are
4393              possible. */
4394           && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4395       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4396       || TREE_CODE (type) == UNKNOWN_TYPE
4397       /* The declaration of a template specialization does not affect
4398          the functions available for overload resolution, so we do not
4399          call pushdecl.  */
4400       || (TREE_CODE (decl) == FUNCTION_DECL
4401           && DECL_TEMPLATE_SPECIALIZATION (decl)))
4402     return decl;
4403   else
4404     return pushdecl (decl);
4405 }
4406
4407 /* Make the declaration(s) of X appear in CLASS scope
4408    under the name NAME.  */
4409
4410 void
4411 push_class_level_binding (name, x)
4412      tree name;
4413      tree x;
4414 {
4415   tree binding;
4416   /* The class_binding_level will be NULL if x is a template
4417      parameter name in a member template.  */
4418   if (!class_binding_level)
4419     return;
4420
4421   /* Make sure that this new member does not have the same name
4422      as a template parameter.  */
4423   if (TYPE_BEING_DEFINED (current_class_type))
4424     check_template_shadow (x);
4425
4426   /* If this declaration shadows a declaration from an enclosing
4427      class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4428      we leave this class.  Record the shadowed declaration here.  */
4429   binding = IDENTIFIER_BINDING (name);
4430   if (binding
4431       && ((TREE_CODE (x) == OVERLOAD
4432            && BINDING_VALUE (binding)
4433            && is_overloaded_fn (BINDING_VALUE (binding)))
4434           || INHERITED_VALUE_BINDING_P (binding)))
4435     {
4436       tree shadow;
4437       tree old_decl;
4438
4439       /* If the old binding was from a base class, and was for a tag
4440          name, slide it over to make room for the new binding.  The
4441          old binding is still visible if explicitly qualified with a
4442          class-key.  */
4443       if (INHERITED_VALUE_BINDING_P (binding)
4444           && BINDING_VALUE (binding)
4445           && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4446           && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4447           && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4448         {
4449           old_decl = BINDING_TYPE (binding);
4450           BINDING_TYPE (binding) = BINDING_VALUE (binding);
4451           BINDING_VALUE (binding) = NULL_TREE;
4452           INHERITED_VALUE_BINDING_P (binding) = 0;
4453         }
4454       else
4455         old_decl = BINDING_VALUE (binding);
4456
4457       /* There was already a binding for X containing fewer
4458          functions than are named in X.  Find the previous
4459          declaration of X on the class-shadowed list, and update it.  */
4460       for (shadow = class_binding_level->class_shadowed;
4461            shadow;
4462            shadow = TREE_CHAIN (shadow))
4463         if (TREE_PURPOSE (shadow) == name
4464             && TREE_TYPE (shadow) == old_decl)
4465           {
4466             BINDING_VALUE (binding) = x;
4467             INHERITED_VALUE_BINDING_P (binding) = 0;
4468             TREE_TYPE (shadow) = x;
4469             return;
4470           }
4471     }
4472
4473   /* If we didn't replace an existing binding, put the binding on the
4474      stack of bindings for the identifier, and update
4475      IDENTIFIER_CLASS_VALUE.  */
4476   if (push_class_binding (name, x))
4477     {
4478       class_binding_level->class_shadowed
4479         = tree_cons (name, IDENTIFIER_CLASS_VALUE (name),
4480                      class_binding_level->class_shadowed);
4481       /* Record the value we are binding NAME to so that we can know
4482          what to pop later.  */
4483       TREE_TYPE (class_binding_level->class_shadowed) = x;
4484     }
4485 }
4486
4487 /* Insert another USING_DECL into the current binding level, returning
4488    this declaration. If this is a redeclaration, do nothing, and
4489    return NULL_TREE if this not in namespace scope (in namespace
4490    scope, a using decl might extend any previous bindings).  */
4491
4492 tree
4493 push_using_decl (scope, name)
4494      tree scope;
4495      tree name;
4496 {
4497   tree decl;
4498
4499   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4500   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4501   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4502     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4503       break;
4504   if (decl)
4505     return namespace_bindings_p () ? decl : NULL_TREE;
4506   decl = build_lang_decl (USING_DECL, name, void_type_node);
4507   DECL_INITIAL (decl) = scope;
4508   TREE_CHAIN (decl) = current_binding_level->usings;
4509   current_binding_level->usings = decl;
4510   return decl;
4511 }
4512
4513 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4514    changed (i.e. there was already a directive), or the fresh
4515    TREE_LIST otherwise.  */
4516
4517 tree
4518 push_using_directive (used)
4519      tree used;
4520 {
4521   tree ud = current_binding_level->using_directives;
4522   tree iter, ancestor;
4523
4524   /* Check if we already have this. */
4525   if (purpose_member (used, ud) != NULL_TREE)
4526     return NULL_TREE;
4527
4528   /* Recursively add all namespaces used. */
4529   for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4530     push_using_directive (TREE_PURPOSE (iter));
4531
4532   ancestor = namespace_ancestor (current_decl_namespace (), used);
4533   ud = current_binding_level->using_directives;
4534   ud = tree_cons (used, ancestor, ud);
4535   current_binding_level->using_directives = ud;
4536   return ud;
4537 }
4538
4539 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4540    other definitions already in place.  We get around this by making
4541    the value of the identifier point to a list of all the things that
4542    want to be referenced by that name.  It is then up to the users of
4543    that name to decide what to do with that list.
4544
4545    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
4546    DECL_TEMPLATE_RESULT.  It is dealt with the same way.
4547
4548    FLAGS is a bitwise-or of the following values:
4549      PUSH_LOCAL: Bind DECL in the current scope, rather than at
4550                  namespace scope.
4551      PUSH_USING: DECL is being pushed as the result of a using
4552                  declaration.
4553
4554    The value returned may be a previous declaration if we guessed wrong
4555    about what language DECL should belong to (C or C++).  Otherwise,
4556    it's always DECL (and never something that's not a _DECL).  */
4557
4558 tree
4559 push_overloaded_decl (decl, flags)
4560      tree decl;
4561      int flags;
4562 {
4563   tree name = DECL_NAME (decl);
4564   tree old;
4565   tree new_binding;
4566   int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4567
4568   if (doing_global)
4569     old = namespace_binding (name, DECL_CONTEXT (decl));
4570   else
4571     old = lookup_name_current_level (name);
4572
4573   if (old)
4574     {
4575       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4576         {
4577           tree t = TREE_TYPE (old);
4578           if (IS_AGGR_TYPE (t) && warn_shadow
4579               && (! DECL_IN_SYSTEM_HEADER (decl)
4580                   || ! DECL_IN_SYSTEM_HEADER (old)))
4581             cp_warning ("`%#D' hides constructor for `%#T'", decl, t);
4582           old = NULL_TREE;
4583         }
4584       else if (is_overloaded_fn (old))
4585         {
4586           tree tmp;
4587
4588           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4589             {
4590               tree fn = OVL_CURRENT (tmp);
4591
4592               if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4593                   && !(flags & PUSH_USING)
4594                   && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4595                                 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4596                 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4597                           decl, fn);
4598
4599               if (duplicate_decls (decl, fn))
4600                 return fn;
4601             }
4602         }
4603       else if (old == error_mark_node)
4604         /* Ignore the undefined symbol marker.  */
4605         old = NULL_TREE;
4606       else
4607         {
4608           cp_error_at ("previous non-function declaration `%#D'", old);
4609           cp_error ("conflicts with function declaration `%#D'", decl);
4610           return decl;
4611         }
4612     }
4613
4614   if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4615     {
4616       if (old && TREE_CODE (old) != OVERLOAD)
4617         new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4618       else
4619         new_binding = ovl_cons (decl, old);
4620       if (flags & PUSH_USING)
4621         OVL_USED (new_binding) = 1;
4622     }
4623   else
4624     /* NAME is not ambiguous.  */
4625     new_binding = decl;
4626
4627   if (doing_global)
4628     set_namespace_binding (name, current_namespace, new_binding);
4629   else
4630     {
4631       /* We only create an OVERLOAD if there was a previous binding at
4632          this level, or if decl is a template. In the former case, we
4633          need to remove the old binding and replace it with the new
4634          binding.  We must also run through the NAMES on the binding
4635          level where the name was bound to update the chain.  */
4636
4637       if (TREE_CODE (new_binding) == OVERLOAD && old)
4638         {
4639           tree *d;
4640
4641           for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4642                *d;
4643                d = &TREE_CHAIN (*d))
4644             if (*d == old
4645                 || (TREE_CODE (*d) == TREE_LIST
4646                     && TREE_VALUE (*d) == old))
4647               {
4648                 if (TREE_CODE (*d) == TREE_LIST)
4649                   /* Just replace the old binding with the new.  */
4650                   TREE_VALUE (*d) = new_binding;
4651                 else
4652                   /* Build a TREE_LIST to wrap the OVERLOAD.  */
4653                   *d = tree_cons (NULL_TREE, new_binding,
4654                                   TREE_CHAIN (*d));
4655
4656                 /* And update the CPLUS_BINDING node.  */
4657                 BINDING_VALUE (IDENTIFIER_BINDING (name))
4658                   = new_binding;
4659                 return decl;
4660               }
4661
4662           /* We should always find a previous binding in this case.  */
4663           my_friendly_abort (0);
4664         }
4665
4666       /* Install the new binding.  */
4667       push_local_binding (name, new_binding, flags);
4668     }
4669
4670   return decl;
4671 }
4672 \f
4673 /* Generate an implicit declaration for identifier FUNCTIONID
4674    as a function of type int ().  Print a warning if appropriate.  */
4675
4676 tree
4677 implicitly_declare (functionid)
4678      tree functionid;
4679 {
4680   register tree decl;
4681
4682   /* We used to reuse an old implicit decl here,
4683      but this loses with inline functions because it can clobber
4684      the saved decl chains.  */
4685   decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4686
4687   DECL_EXTERNAL (decl) = 1;
4688   TREE_PUBLIC (decl) = 1;
4689
4690   /* ISO standard says implicit declarations are in the innermost block.
4691      So we record the decl in the standard fashion.  */
4692   pushdecl (decl);
4693   rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
4694
4695   if (warn_implicit
4696       /* Only one warning per identifier.  */
4697       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4698     {
4699       cp_pedwarn ("implicit declaration of function `%#D'", decl);
4700     }
4701
4702   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4703
4704   return decl;
4705 }
4706
4707 /* Return zero if the declaration NEWDECL is valid
4708    when the declaration OLDDECL (assumed to be for the same name)
4709    has already been seen.
4710    Otherwise return an error message format string with a %s
4711    where the identifier should go.  */
4712
4713 static const char *
4714 redeclaration_error_message (newdecl, olddecl)
4715      tree newdecl, olddecl;
4716 {
4717   if (TREE_CODE (newdecl) == TYPE_DECL)
4718     {
4719       /* Because C++ can put things into name space for free,
4720          constructs like "typedef struct foo { ... } foo"
4721          would look like an erroneous redeclaration.  */
4722       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4723         return 0;
4724       else
4725         return "redefinition of `%#D'";
4726     }
4727   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4728     {
4729       /* If this is a pure function, its olddecl will actually be
4730          the original initialization to `0' (which we force to call
4731          abort()).  Don't complain about redefinition in this case.  */
4732       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4733         return 0;
4734
4735       /* If both functions come from different namespaces, this is not
4736          a redeclaration - this is a conflict with a used function. */
4737       if (DECL_NAMESPACE_SCOPE_P (olddecl)
4738           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4739         return "`%D' conflicts with used function";
4740
4741       /* We'll complain about linkage mismatches in
4742          warn_extern_redeclared_static.  */
4743
4744       /* Defining the same name twice is no good.  */
4745       if (DECL_INITIAL (olddecl) != NULL_TREE
4746           && DECL_INITIAL (newdecl) != NULL_TREE)
4747         {
4748           if (DECL_NAME (olddecl) == NULL_TREE)
4749             return "`%#D' not declared in class";
4750           else
4751             return "redefinition of `%#D'";
4752         }
4753       return 0;
4754     }
4755   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4756     {
4757       if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4758            && (DECL_TEMPLATE_RESULT (newdecl)
4759                != DECL_TEMPLATE_RESULT (olddecl))
4760            && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4761            && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4762           || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4763               && COMPLETE_TYPE_P (TREE_TYPE (newdecl))
4764               && COMPLETE_TYPE_P (TREE_TYPE (olddecl))))
4765         return "redefinition of `%#D'";
4766       return 0;
4767     }
4768   else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
4769     {
4770       /* Objects declared at top level:  */
4771       /* If at least one is a reference, it's ok.  */
4772       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4773         return 0;
4774       /* Reject two definitions.  */
4775       return "redefinition of `%#D'";
4776     }
4777   else
4778     {
4779       /* Objects declared with block scope:  */
4780       /* Reject two definitions, and reject a definition
4781          together with an external reference.  */
4782       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4783         return "redeclaration of `%#D'";
4784       return 0;
4785     }
4786 }
4787 \f
4788 /* Create a new label, named ID.  */
4789
4790 static tree
4791 make_label_decl (id, local_p)
4792      tree id;
4793      int local_p;
4794 {
4795   tree decl;
4796
4797   decl = build_decl (LABEL_DECL, id, void_type_node);
4798   if (expanding_p)
4799     /* Make sure every label has an rtx.  */
4800     label_rtx (decl);
4801
4802   DECL_CONTEXT (decl) = current_function_decl;
4803   DECL_MODE (decl) = VOIDmode;
4804   C_DECLARED_LABEL_FLAG (decl) = local_p;
4805
4806   /* Say where one reference is to the label, for the sake of the
4807      error if it is not defined.  */
4808   DECL_SOURCE_LINE (decl) = lineno;
4809   DECL_SOURCE_FILE (decl) = input_filename;
4810
4811   /* Record the fact that this identifier is bound to this label.  */
4812   SET_IDENTIFIER_LABEL_VALUE (id, decl);
4813
4814   return decl;
4815 }
4816
4817 /* Record this label on the list of used labels so that we can check
4818    at the end of the function to see whether or not the label was
4819    actually defined, and so we can check when the label is defined whether
4820    this use is valid.  */
4821
4822 static void
4823 use_label (decl)
4824      tree decl;
4825 {
4826   if (named_label_uses == NULL
4827       || named_label_uses->names_in_scope != current_binding_level->names
4828       || named_label_uses->label_decl != decl)
4829     {
4830       struct named_label_use_list *new_ent;
4831       new_ent = ((struct named_label_use_list *)
4832                  ggc_alloc (sizeof (struct named_label_use_list)));
4833       new_ent->label_decl = decl;
4834       new_ent->names_in_scope = current_binding_level->names;
4835       new_ent->binding_level = current_binding_level;
4836       new_ent->lineno_o_goto = lineno;
4837       new_ent->filename_o_goto = input_filename;
4838       new_ent->next = named_label_uses;
4839       named_label_uses = new_ent;
4840     }
4841 }
4842
4843 /* Look for a label named ID in the current function.  If one cannot
4844    be found, create one.  (We keep track of used, but undefined,
4845    labels, and complain about them at the end of a function.)  */
4846
4847 tree
4848 lookup_label (id)
4849      tree id;
4850 {
4851   tree decl;
4852   struct named_label_list *ent;
4853
4854   /* You can't use labels at global scope.  */
4855   if (current_function_decl == NULL_TREE)
4856     {
4857       error ("label `%s' referenced outside of any function",
4858              IDENTIFIER_POINTER (id));
4859       return NULL_TREE;
4860     }
4861
4862   /* See if we've already got this label.  */
4863   decl = IDENTIFIER_LABEL_VALUE (id);
4864   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4865     return decl;
4866
4867   /* Record this label on the list of labels used in this function.
4868      We do this before calling make_label_decl so that we get the
4869      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
4870   ent = ((struct named_label_list *)
4871          ggc_alloc_cleared (sizeof (struct named_label_list)));
4872   ent->old_value = IDENTIFIER_LABEL_VALUE (id);
4873   ent->next = named_labels;
4874   named_labels = ent;
4875
4876   /* We need a new label.  */
4877   decl = make_label_decl (id, /*local_p=*/0);
4878
4879   /* Now fill in the information we didn't have before.  */
4880   ent->label_decl = decl;
4881
4882   return decl;
4883 }
4884
4885 /* Declare a local label named ID.  */
4886
4887 tree
4888 declare_local_label (id)
4889      tree id;
4890 {
4891   tree decl;
4892
4893   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4894      this scope we can restore the old value of
4895      IDENTIFIER_TYPE_VALUE.  */
4896   current_binding_level->shadowed_labels
4897     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4898                  current_binding_level->shadowed_labels);
4899   /* Look for the label.  */
4900   decl = make_label_decl (id, /*local_p=*/1);
4901   /* Now fill in the information we didn't have before.  */
4902   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4903
4904   return decl;
4905 }
4906
4907 /* Returns nonzero if it is ill-formed to jump past the declaration of
4908    DECL.  Returns 2 if it's also a real problem.  */
4909
4910 static int
4911 decl_jump_unsafe (decl)
4912      tree decl;
4913 {
4914   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
4915     return 0;
4916
4917   if (DECL_INITIAL (decl) == NULL_TREE
4918       && pod_type_p (TREE_TYPE (decl)))
4919     return 0;
4920
4921   /* This is really only important if we're crossing an initialization.
4922      The POD stuff is just pedantry; why should it matter if the class
4923      contains a field of pointer to member type?  */
4924   if (DECL_INITIAL (decl)
4925       || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
4926     return 2;
4927   return 1;
4928 }
4929
4930 /* Check that a single previously seen jump to a newly defined label
4931    is OK.  DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
4932    the jump context; NAMES are the names in scope in LEVEL at the jump
4933    context; FILE and LINE are the source position of the jump or 0.  */
4934
4935 static void
4936 check_previous_goto_1 (decl, level, names, file, line)
4937      tree decl;
4938      struct binding_level *level;
4939      tree names;
4940      const char *file;
4941      int line;
4942 {
4943   int identified = 0;
4944   int saw_eh = 0;
4945   struct binding_level *b = current_binding_level;
4946   for (; b; b = b->level_chain)
4947     {
4948       tree new_decls = b->names;
4949       tree old_decls = (b == level ? names : NULL_TREE);
4950       for (; new_decls != old_decls;
4951            new_decls = TREE_CHAIN (new_decls))
4952         {
4953           int problem = decl_jump_unsafe (new_decls);
4954           if (! problem)
4955             continue;
4956
4957           if (! identified)
4958             {
4959               if (decl)
4960                 cp_pedwarn ("jump to label `%D'", decl);
4961               else
4962                 pedwarn ("jump to case label");
4963
4964               if (file)
4965                 pedwarn_with_file_and_line (file, line, "  from here");
4966               identified = 1;
4967             }
4968
4969           if (problem > 1 && DECL_ARTIFICIAL (new_decls))
4970             /* Can't skip init of __exception_info.  */
4971             cp_error_at ("  enters catch block", new_decls);
4972           else if (problem > 1)
4973             cp_error_at ("  crosses initialization of `%#D'",
4974                          new_decls);
4975           else
4976             cp_pedwarn_at ("  enters scope of non-POD `%#D'",
4977                            new_decls);
4978         }
4979
4980       if (b == level)
4981         break;
4982       if (b->eh_region && ! saw_eh)
4983         {
4984           if (! identified)
4985             {
4986               if (decl)
4987                 cp_pedwarn ("jump to label `%D'", decl);
4988               else
4989                 pedwarn ("jump to case label");
4990
4991               if (file)
4992                 pedwarn_with_file_and_line (file, line, "  from here");
4993               identified = 1;
4994             }
4995           error ("  enters try block");
4996           saw_eh = 1;
4997         }
4998     }
4999 }
5000
5001 static void
5002 check_previous_goto (use)
5003      struct named_label_use_list *use;
5004 {
5005   check_previous_goto_1 (use->label_decl, use->binding_level,
5006                          use->names_in_scope, use->filename_o_goto,
5007                          use->lineno_o_goto);
5008 }
5009
5010 static void
5011 check_switch_goto (level)
5012      struct binding_level *level;
5013 {
5014   check_previous_goto_1 (NULL_TREE, level, level->names, NULL, 0);
5015 }
5016
5017 /* Check that any previously seen jumps to a newly defined label DECL
5018    are OK.  Called by define_label.  */
5019
5020 static void
5021 check_previous_gotos (decl)
5022      tree decl;
5023 {
5024   struct named_label_use_list **usep;
5025
5026   if (! TREE_USED (decl))
5027     return;
5028
5029   for (usep = &named_label_uses; *usep; )
5030     {
5031       struct named_label_use_list *use = *usep;
5032       if (use->label_decl == decl)
5033         {
5034           check_previous_goto (use);
5035           *usep = use->next;
5036         }
5037       else
5038         usep = &(use->next);
5039     }
5040 }
5041
5042 /* Check that a new jump to a label DECL is OK.  Called by
5043    finish_goto_stmt.  */
5044
5045 void
5046 check_goto (decl)
5047      tree decl;
5048 {
5049   int identified = 0;
5050   tree bad;
5051   struct named_label_list *lab;
5052
5053   /* We can't know where a computed goto is jumping.  So we assume
5054      that it's OK.  */
5055   if (! DECL_P (decl))
5056     return;
5057
5058   /* If the label hasn't been defined yet, defer checking.  */
5059   if (! DECL_INITIAL (decl))
5060     {
5061       use_label (decl);
5062       return;
5063     }
5064
5065   for (lab = named_labels; lab; lab = lab->next)
5066     if (decl == lab->label_decl)
5067       break;
5068
5069   /* If the label is not on named_labels it's a gcc local label, so
5070      it must be in an outer scope, so jumping to it is always OK.  */
5071   if (lab == 0)
5072     return;
5073
5074   if ((lab->eh_region || lab->bad_decls) && !identified)
5075     {
5076       cp_pedwarn_at ("jump to label `%D'", decl);
5077       pedwarn ("  from here");
5078       identified = 1;
5079     }
5080
5081   for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad))
5082     {
5083       tree b = TREE_VALUE (bad);
5084       int u = decl_jump_unsafe (b);
5085
5086       if (u > 1 && DECL_ARTIFICIAL (b))
5087         /* Can't skip init of __exception_info.  */
5088         cp_error_at ("  enters catch block", b);
5089       else if (u > 1)
5090         cp_error_at ("  skips initialization of `%#D'", b);
5091       else
5092         cp_pedwarn_at ("  enters scope of non-POD `%#D'", b);
5093     }
5094
5095   if (lab->eh_region)
5096     error ("  enters try block");
5097 }
5098
5099 /* Define a label, specifying the location in the source file.
5100    Return the LABEL_DECL node for the label, if the definition is valid.
5101    Otherwise return 0.  */
5102
5103 tree
5104 define_label (filename, line, name)
5105      const char *filename;
5106      int line;
5107      tree name;
5108 {
5109   tree decl = lookup_label (name);
5110   struct named_label_list *ent;
5111
5112   for (ent = named_labels; ent; ent = ent->next)
5113     if (ent->label_decl == decl)
5114       break;
5115
5116   /* After labels, make any new cleanups go into their
5117      own new (temporary) binding contour.  */
5118   current_binding_level->more_cleanups_ok = 0;
5119
5120   if (name == get_identifier ("wchar_t"))
5121     cp_pedwarn ("label named wchar_t");
5122
5123   if (DECL_INITIAL (decl) != NULL_TREE)
5124     {
5125       cp_error ("duplicate label `%D'", decl);
5126       return 0;
5127     }
5128   else
5129     {
5130       /* Mark label as having been defined.  */
5131       DECL_INITIAL (decl) = error_mark_node;
5132       /* Say where in the source.  */
5133       DECL_SOURCE_FILE (decl) = filename;
5134       DECL_SOURCE_LINE (decl) = line;
5135       if (ent)
5136         {
5137           ent->names_in_scope = current_binding_level->names;
5138           ent->binding_level = current_binding_level;
5139         }
5140       check_previous_gotos (decl);
5141       current_function_return_value = NULL_TREE;
5142       return decl;
5143     }
5144 }
5145
5146 struct cp_switch
5147 {
5148   struct binding_level *level;
5149   struct cp_switch *next;
5150 };
5151
5152 static struct cp_switch *switch_stack;
5153
5154 void
5155 push_switch ()
5156 {
5157   struct cp_switch *p
5158     = (struct cp_switch *) xmalloc (sizeof (struct cp_switch));
5159   p->level = current_binding_level;
5160   p->next = switch_stack;
5161   switch_stack = p;
5162 }
5163
5164 void
5165 pop_switch ()
5166 {
5167   struct cp_switch *cs;
5168
5169   cs = switch_stack;
5170   switch_stack = switch_stack->next;
5171   free (cs);
5172 }
5173
5174 /* Note that we've seen a definition of a case label, and complain if this
5175    is a bad place for one.  */
5176
5177 void
5178 define_case_label ()
5179 {
5180   tree cleanup = last_cleanup_this_contour ();
5181
5182   if (! switch_stack)
5183     /* Don't crash; we'll complain in do_case.  */
5184     return;
5185
5186   if (cleanup)
5187     {
5188       static int explained = 0;
5189       cp_warning_at ("destructor needed for `%#D'", TREE_PURPOSE (cleanup));
5190       warning ("where case label appears here");
5191       if (!explained)
5192         {
5193           warning ("(enclose actions of previous case statements requiring");
5194           warning ("destructors in their own binding contours.)");
5195           explained = 1;
5196         }
5197     }
5198
5199   check_switch_goto (switch_stack->level);
5200
5201   /* After labels, make any new cleanups go into their
5202      own new (temporary) binding contour.  */
5203
5204   current_binding_level->more_cleanups_ok = 0;
5205   current_function_return_value = NULL_TREE;
5206 }
5207 \f
5208 /* Return the list of declarations of the current level.
5209    Note that this list is in reverse order unless/until
5210    you nreverse it; and when you do nreverse it, you must
5211    store the result back using `storedecls' or you will lose.  */
5212
5213 tree
5214 getdecls ()
5215 {
5216   return current_binding_level->names;
5217 }
5218
5219 /* Return the list of type-tags (for structs, etc) of the current level.  */
5220
5221 tree
5222 gettags ()
5223 {
5224   return current_binding_level->tags;
5225 }
5226
5227 /* Store the list of declarations of the current level.
5228    This is done for the parameter declarations of a function being defined,
5229    after they are modified in the light of any missing parameters.  */
5230
5231 static void
5232 storedecls (decls)
5233      tree decls;
5234 {
5235   current_binding_level->names = decls;
5236 }
5237
5238 /* Similarly, store the list of tags of the current level.  */
5239
5240 void
5241 storetags (tags)
5242      tree tags;
5243 {
5244   current_binding_level->tags = tags;
5245 }
5246 \f
5247 /* Given NAME, an IDENTIFIER_NODE,
5248    return the structure (or union or enum) definition for that name.
5249    Searches binding levels from BINDING_LEVEL up to the global level.
5250    If THISLEVEL_ONLY is nonzero, searches only the specified context
5251    (but skips any tag-transparent contexts to find one that is
5252    meaningful for tags).
5253    FORM says which kind of type the caller wants;
5254    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5255    If the wrong kind of type is found, and it's not a template, an error is
5256    reported.  */
5257
5258 static tree
5259 lookup_tag (form, name, binding_level, thislevel_only)
5260      enum tree_code form;
5261      tree name;
5262      struct binding_level *binding_level;
5263      int thislevel_only;
5264 {
5265   register struct binding_level *level;
5266   /* Non-zero if, we should look past a template parameter level, even
5267      if THISLEVEL_ONLY.  */
5268   int allow_template_parms_p = 1;
5269
5270   for (level = binding_level; level; level = level->level_chain)
5271     {
5272       register tree tail;
5273       if (ANON_AGGRNAME_P (name))
5274         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5275           {
5276             /* There's no need for error checking here, because
5277                anon names are unique throughout the compilation.  */
5278             if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
5279               return TREE_VALUE (tail);
5280           }
5281       else if (level->namespace_p)
5282         /* Do namespace lookup. */
5283         for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
5284           {
5285             tree old = binding_for_name (name, tail);
5286
5287             /* If we just skipped past a template parameter level,
5288                even though THISLEVEL_ONLY, and we find a template
5289                class declaration, then we use the _TYPE node for the
5290                template.  See the example below.  */
5291             if (thislevel_only && !allow_template_parms_p
5292                 && old && BINDING_VALUE (old)
5293                 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
5294               old = TREE_TYPE (BINDING_VALUE (old));
5295             else
5296               old = BINDING_TYPE (old);
5297
5298             /* If it has an original type, it is a typedef, and we
5299                should not return it.  */
5300             if (old && DECL_ORIGINAL_TYPE (TYPE_NAME (old)))
5301               old = NULL_TREE;
5302             if (old && TREE_CODE (old) != form
5303                 && !(form != ENUMERAL_TYPE && TREE_CODE (old) == TEMPLATE_DECL))
5304               {
5305                 cp_error ("`%#D' redeclared as %C", old, form);
5306                 return NULL_TREE;
5307               }
5308             if (old)
5309               return old;
5310             if (thislevel_only || tail == global_namespace)
5311               return NULL_TREE;
5312           }
5313       else
5314         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5315           {
5316             if (TREE_PURPOSE (tail) == name)
5317               {
5318                 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5319                 /* Should tighten this up; it'll probably permit
5320                    UNION_TYPE and a struct template, for example.  */
5321                 if (code != form
5322                     && !(form != ENUMERAL_TYPE && code == TEMPLATE_DECL))
5323                   {
5324                     /* Definition isn't the kind we were looking for.  */
5325                     cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
5326                               form);
5327                     return NULL_TREE;
5328                   }
5329                 return TREE_VALUE (tail);
5330               }
5331           }
5332       if (thislevel_only && ! level->tag_transparent)
5333         {
5334           if (level->template_parms_p && allow_template_parms_p)
5335             {
5336               /* We must deal with cases like this:
5337
5338                    template <class T> struct S;
5339                    template <class T> struct S {};
5340
5341                  When looking up `S', for the second declaration, we
5342                  would like to find the first declaration.  But, we
5343                  are in the pseudo-global level created for the
5344                  template parameters, rather than the (surrounding)
5345                  namespace level.  Thus, we keep going one more level,
5346                  even though THISLEVEL_ONLY is non-zero.  */
5347               allow_template_parms_p = 0;
5348               continue;
5349             }
5350           else
5351             return NULL_TREE;
5352         }
5353     }
5354   return NULL_TREE;
5355 }
5356
5357 #if 0
5358 void
5359 set_current_level_tags_transparency (tags_transparent)
5360      int tags_transparent;
5361 {
5362   current_binding_level->tag_transparent = tags_transparent;
5363 }
5364 #endif
5365
5366 /* Given a type, find the tag that was defined for it and return the tag name.
5367    Otherwise return 0.  However, the value can never be 0
5368    in the cases in which this is used.
5369
5370    C++: If NAME is non-zero, this is the new name to install.  This is
5371    done when replacing anonymous tags with real tag names.  */
5372
5373 static tree
5374 lookup_tag_reverse (type, name)
5375      tree type;
5376      tree name;
5377 {
5378   register struct binding_level *level;
5379
5380   for (level = current_binding_level; level; level = level->level_chain)
5381     {
5382       register tree tail;
5383       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5384         {
5385           if (TREE_VALUE (tail) == type)
5386             {
5387               if (name)
5388                 TREE_PURPOSE (tail) = name;
5389               return TREE_PURPOSE (tail);
5390             }
5391         }
5392     }
5393   return NULL_TREE;
5394 }
5395 \f
5396 /* Look up NAME in the NAMESPACE.  */
5397
5398 tree
5399 lookup_namespace_name (namespace, name)
5400      tree namespace, name;
5401 {
5402   tree val;
5403   tree template_id = NULL_TREE;
5404
5405   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5406
5407   if (TREE_CODE (name) == NAMESPACE_DECL)
5408     /* This happens for A::B<int> when B is a namespace. */
5409     return name;
5410   else if (TREE_CODE (name) == TEMPLATE_DECL)
5411     {
5412       /* This happens for A::B where B is a template, and there are no
5413          template arguments.  */
5414       cp_error ("invalid use of `%D'", name);
5415       return error_mark_node;
5416     }
5417
5418   namespace = ORIGINAL_NAMESPACE (namespace);
5419
5420   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5421     {
5422       template_id = name;
5423       name = TREE_OPERAND (name, 0);
5424       if (TREE_CODE (name) == OVERLOAD)
5425         name = DECL_NAME (OVL_CURRENT (name));
5426       else if (DECL_P (name))
5427         name = DECL_NAME (name);
5428     }
5429
5430   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5431
5432   val = make_node (CPLUS_BINDING);
5433   if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5434     return error_mark_node;
5435
5436   if (BINDING_VALUE (val))
5437     {
5438       val = BINDING_VALUE (val);
5439
5440       if (template_id)
5441         {
5442           if (DECL_CLASS_TEMPLATE_P (val))
5443             val = lookup_template_class (val,
5444                                          TREE_OPERAND (template_id, 1),
5445                                          /*in_decl=*/NULL_TREE,
5446                                          /*context=*/NULL_TREE,
5447                                          /*entering_scope=*/0);
5448           else if (DECL_FUNCTION_TEMPLATE_P (val)
5449                    || TREE_CODE (val) == OVERLOAD)
5450             val = lookup_template_function (val,
5451                                             TREE_OPERAND (template_id, 1));
5452           else
5453             {
5454               cp_error ("`%D::%D' is not a template",
5455                         namespace, name);
5456               return error_mark_node;
5457             }
5458         }
5459
5460       /* If we have a single function from a using decl, pull it out.  */
5461       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5462         val = OVL_FUNCTION (val);
5463       return val;
5464     }
5465
5466   cp_error ("`%D' undeclared in namespace `%D'", name, namespace);
5467   return error_mark_node;
5468 }
5469
5470 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
5471
5472 static unsigned long
5473 typename_hash (k)
5474      hash_table_key k;
5475 {
5476   unsigned long hash;
5477   tree t;
5478
5479   t = (tree) k;
5480   hash = (((unsigned long) TYPE_CONTEXT (t))
5481           ^ ((unsigned long) DECL_NAME (TYPE_NAME (t))));
5482
5483   return hash;
5484 }
5485
5486 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
5487
5488 static boolean
5489 typename_compare (k1, k2)
5490      hash_table_key k1;
5491      hash_table_key k2;
5492 {
5493   tree t1;
5494   tree t2;
5495   tree d1;
5496   tree d2;
5497
5498   t1 = (tree) k1;
5499   t2 = (tree) k2;
5500   d1 = TYPE_NAME (t1);
5501   d2 = TYPE_NAME (t2);
5502
5503   return (DECL_NAME (d1) == DECL_NAME (d2)
5504           && same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))
5505           && ((TREE_TYPE (t1) != NULL_TREE)
5506               == (TREE_TYPE (t2) != NULL_TREE))
5507           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5508           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5509 }
5510
5511 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
5512    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
5513    is non-NULL, this type is being created by the implicit typename
5514    extension, and BASE_TYPE is a type named `t' in some base class of
5515    `T' which depends on template parameters.
5516
5517    Returns the new TYPENAME_TYPE.  */
5518
5519 tree
5520 build_typename_type (context, name, fullname, base_type)
5521      tree context;
5522      tree name;
5523      tree fullname;
5524      tree base_type;
5525 {
5526   tree t;
5527   tree d;
5528   struct hash_entry* e;
5529
5530   static struct hash_table ht;
5531
5532   if (!ht.table)
5533     {
5534       static struct hash_table *h = &ht;
5535       if (!hash_table_init (&ht, &hash_newfunc, &typename_hash,
5536                             &typename_compare))
5537         fatal ("virtual memory exhausted");
5538       ggc_add_tree_hash_table_root (&h, 1);
5539     }
5540
5541   /* Build the TYPENAME_TYPE.  */
5542   t = make_aggr_type (TYPENAME_TYPE);
5543   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5544   TYPENAME_TYPE_FULLNAME (t) = fullname;
5545   TREE_TYPE (t) = base_type;
5546
5547   /* Build the corresponding TYPE_DECL.  */
5548   d = build_decl (TYPE_DECL, name, t);
5549   TYPE_NAME (TREE_TYPE (d)) = d;
5550   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5551   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5552   DECL_ARTIFICIAL (d) = 1;
5553
5554   /* See if we already have this type.  */
5555   e = hash_lookup (&ht, t, /*create=*/false, /*copy=*/0);
5556   if (e)
5557     t = (tree) e->key;
5558   else
5559     /* Insert the type into the table.  */
5560     hash_lookup (&ht, t, /*create=*/true, /*copy=*/0);
5561
5562   return t;
5563 }
5564
5565 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
5566    unless an error occurs, in which case error_mark_node is returned.
5567    If COMPLAIN zero, don't complain about any errors that occur.  */
5568
5569 tree
5570 make_typename_type (context, name, complain)
5571      tree context, name;
5572      int complain;
5573 {
5574   tree fullname;
5575
5576   if (TYPE_P (name))
5577     {
5578       if (!(TYPE_LANG_SPECIFIC (name)
5579             && (CLASSTYPE_IS_TEMPLATE (name)
5580                 || CLASSTYPE_USE_TEMPLATE (name))))
5581         name = TYPE_IDENTIFIER (name);
5582       else
5583         /* Create a TEMPLATE_ID_EXPR for the type.  */
5584         name = build_nt (TEMPLATE_ID_EXPR,
5585                          CLASSTYPE_TI_TEMPLATE (name),
5586                          CLASSTYPE_TI_ARGS (name));
5587     }
5588   else if (TREE_CODE (name) == TYPE_DECL)
5589     name = DECL_NAME (name);
5590
5591   fullname = name;
5592
5593   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5594     {
5595       name = TREE_OPERAND (name, 0);
5596       if (TREE_CODE (name) == TEMPLATE_DECL)
5597         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5598     }
5599   if (TREE_CODE (name) != IDENTIFIER_NODE)
5600     my_friendly_abort (2000);
5601
5602   if (TREE_CODE (context) == NAMESPACE_DECL)
5603     {
5604       /* We can get here from typename_sub0 in the explicit_template_type
5605          expansion.  Just fail.  */
5606       if (complain)
5607         cp_error ("no class template named `%#T' in `%#T'",
5608                   name, context);
5609       return error_mark_node;
5610     }
5611
5612   if (! uses_template_parms (context)
5613       || currently_open_class (context))
5614     {
5615       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5616         {
5617           tree tmpl = NULL_TREE;
5618           if (IS_AGGR_TYPE (context))
5619             tmpl = lookup_field (context, name, 0, 0);
5620           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5621             {
5622               if (complain)
5623                 cp_error ("no class template named `%#T' in `%#T'",
5624                           name, context);
5625               return error_mark_node;
5626             }
5627
5628           return lookup_template_class (tmpl,
5629                                         TREE_OPERAND (fullname, 1),
5630                                         NULL_TREE, context,
5631                                         /*entering_scope=*/0);
5632         }
5633       else
5634         {
5635           tree t;
5636
5637           if (!IS_AGGR_TYPE (context))
5638             {
5639               if (complain)
5640                 cp_error ("no type named `%#T' in `%#T'", name, context);
5641               return error_mark_node;
5642             }
5643
5644           t = lookup_field (context, name, 0, 1);
5645           if (t)
5646             return TREE_TYPE (t);
5647         }
5648     }
5649
5650   /* If the CONTEXT is not a template type, then either the field is
5651      there now or its never going to be.  */
5652   if (!uses_template_parms (context))
5653     {
5654       if (complain)
5655         cp_error ("no type named `%#T' in `%#T'", name, context);
5656       return error_mark_node;
5657     }
5658
5659
5660   return build_typename_type (context, name, fullname,  NULL_TREE);
5661 }
5662
5663 /* Select the right _DECL from multiple choices. */
5664
5665 static tree
5666 select_decl (binding, flags)
5667      tree binding;
5668      int flags;
5669 {
5670   tree val;
5671   val = BINDING_VALUE (binding);
5672   if (LOOKUP_NAMESPACES_ONLY (flags))
5673     {
5674       /* We are not interested in types. */
5675       if (val && TREE_CODE (val) == NAMESPACE_DECL)
5676         return val;
5677       return NULL_TREE;
5678     }
5679
5680   /* If we could have a type and
5681      we have nothing or we need a type and have none.  */
5682   if (BINDING_TYPE (binding)
5683       && (!val || ((flags & LOOKUP_PREFER_TYPES)
5684                    && TREE_CODE (val) != TYPE_DECL)))
5685     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5686   /* Don't return non-types if we really prefer types. */
5687   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
5688            && (TREE_CODE (val) != TEMPLATE_DECL
5689                || !DECL_CLASS_TEMPLATE_P (val)))
5690     val = NULL_TREE;
5691
5692   return val;
5693 }
5694
5695 /* Unscoped lookup of a global: iterate over current namespaces,
5696    considering using-directives.  If SPACESP is non-NULL, store a list
5697    of the namespaces we've considered in it.  */
5698
5699 tree
5700 unqualified_namespace_lookup (name, flags, spacesp)
5701      tree name;
5702      int flags;
5703      tree *spacesp;
5704 {
5705   tree b = make_node (CPLUS_BINDING);
5706   tree initial = current_decl_namespace();
5707   tree scope = initial;
5708   tree siter;
5709   struct binding_level *level;
5710   tree val = NULL_TREE;
5711
5712   if (spacesp)
5713     *spacesp = NULL_TREE;
5714
5715   for (; !val; scope = CP_DECL_CONTEXT (scope))
5716     {
5717       if (spacesp)
5718         *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5719       val = binding_for_name (name, scope);
5720
5721       /* Initialize binding for this context. */
5722       BINDING_VALUE (b) = BINDING_VALUE (val);
5723       BINDING_TYPE (b) = BINDING_TYPE (val);
5724
5725       /* Add all _DECLs seen through local using-directives. */
5726       for (level = current_binding_level;
5727            !level->namespace_p;
5728            level = level->level_chain)
5729         if (!lookup_using_namespace (name, b, level->using_directives,
5730                                      scope, flags, spacesp))
5731           /* Give up because of error. */
5732           return error_mark_node;
5733
5734       /* Add all _DECLs seen through global using-directives. */
5735       /* XXX local and global using lists should work equally. */
5736       siter = initial;
5737       while (1)
5738         {
5739           if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5740                                        scope, flags, spacesp))
5741             /* Give up because of error. */
5742             return error_mark_node;
5743           if (siter == scope) break;
5744           siter = CP_DECL_CONTEXT (siter);
5745         }
5746
5747       val = select_decl (b, flags);
5748       if (scope == global_namespace)
5749         break;
5750     }
5751   return val;
5752 }
5753
5754 /* Combine prefer_type and namespaces_only into flags.  */
5755
5756 static int
5757 lookup_flags (prefer_type, namespaces_only)
5758   int prefer_type, namespaces_only;
5759 {
5760   if (namespaces_only)
5761     return LOOKUP_PREFER_NAMESPACES;
5762   if (prefer_type > 1)
5763     return LOOKUP_PREFER_TYPES;
5764   if (prefer_type > 0)
5765     return LOOKUP_PREFER_BOTH;
5766   return 0;
5767 }
5768
5769 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5770    ignore it or not.  Subroutine of lookup_name_real.  */
5771
5772 static tree
5773 qualify_lookup (val, flags)
5774      tree val;
5775      int flags;
5776 {
5777   if (val == NULL_TREE)
5778     return val;
5779   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5780     return val;
5781   if ((flags & LOOKUP_PREFER_TYPES)
5782       && (TREE_CODE (val) == TYPE_DECL
5783           || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5784               && DECL_CLASS_TEMPLATE_P (val))))
5785     return val;
5786   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5787     return NULL_TREE;
5788   return val;
5789 }
5790
5791 /* Any other BINDING overrides an implicit TYPENAME.  Warn about
5792    that.  */
5793
5794 static void
5795 warn_about_implicit_typename_lookup (typename, binding)
5796      tree typename;
5797      tree binding;
5798 {
5799   tree subtype = TREE_TYPE (TREE_TYPE (typename));
5800   tree name = DECL_NAME (typename);
5801
5802   if (! (TREE_CODE (binding) == TEMPLATE_DECL
5803          && CLASSTYPE_TEMPLATE_INFO (subtype)
5804          && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
5805       && ! (TREE_CODE (binding) == TYPE_DECL
5806             && same_type_p (TREE_TYPE (binding), subtype)))
5807     {
5808       cp_warning ("lookup of `%D' finds `%#D'",
5809                   name, binding);
5810       cp_warning ("  instead of `%D' from dependent base class",
5811                   typename);
5812       cp_warning ("  (use `typename %T::%D' if that's what you meant)",
5813                   constructor_name (current_class_type), name);
5814     }
5815 }
5816
5817 /* Look up NAME in the current binding level and its superiors in the
5818    namespace of variables, functions and typedefs.  Return a ..._DECL
5819    node of some kind representing its definition if there is only one
5820    such declaration, or return a TREE_LIST with all the overloaded
5821    definitions if there are many, or return 0 if it is undefined.
5822
5823    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5824    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5825    If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5826    Otherwise we prefer non-TYPE_DECLs.
5827
5828    If NONCLASS is non-zero, we don't look for the NAME in class scope,
5829    using IDENTIFIER_CLASS_VALUE.  */
5830
5831 static tree
5832 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
5833      tree name;
5834      int prefer_type, nonclass, namespaces_only;
5835 {
5836   tree t;
5837   tree val = NULL_TREE;
5838   int yylex = 0;
5839   tree from_obj = NULL_TREE;
5840   int flags;
5841   int val_is_implicit_typename = 0;
5842
5843   /* Hack: copy flag set by parser, if set. */
5844   if (only_namespace_names)
5845     namespaces_only = 1;
5846
5847   if (prefer_type == -2)
5848     {
5849       extern int looking_for_typename;
5850       tree type = NULL_TREE;
5851
5852       yylex = 1;
5853       prefer_type = looking_for_typename;
5854
5855       flags = lookup_flags (prefer_type, namespaces_only);
5856       /* If the next thing is '<', class templates are types. */
5857       if (looking_for_template)
5858         flags |= LOOKUP_TEMPLATES_EXPECTED;
5859
5860       /* std:: becomes :: for now.  */
5861       if (got_scope == std_node)
5862         got_scope = void_type_node;
5863
5864       if (got_scope)
5865         type = got_scope;
5866       else if (got_object != error_mark_node)
5867         type = got_object;
5868
5869       if (type)
5870         {
5871           if (type == error_mark_node)
5872             return error_mark_node;
5873           if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
5874             type = TREE_TYPE (type);
5875
5876           if (TYPE_P (type))
5877             type = complete_type (type);
5878
5879           if (TREE_CODE (type) == VOID_TYPE)
5880             type = global_namespace;
5881           if (TREE_CODE (type) == NAMESPACE_DECL)
5882             {
5883               val = make_node (CPLUS_BINDING);
5884               flags |= LOOKUP_COMPLAIN;
5885               if (!qualified_lookup_using_namespace (name, type, val, flags))
5886                 return NULL_TREE;
5887               val = select_decl (val, flags);
5888             }
5889           else if (! IS_AGGR_TYPE (type)
5890                    || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5891                    || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM
5892                    || TREE_CODE (type) == TYPENAME_TYPE)
5893             /* Someone else will give an error about this if needed.  */
5894             val = NULL_TREE;
5895           else if (type == current_class_type)
5896             val = IDENTIFIER_CLASS_VALUE (name);
5897           else
5898             {
5899               val = lookup_member (type, name, 0, prefer_type);
5900               type_access_control (type, val);
5901             }
5902         }
5903       else
5904         val = NULL_TREE;
5905
5906       if (got_scope)
5907         goto done;
5908       else if (got_object && val)
5909         from_obj = val;
5910     }
5911   else
5912     {
5913       flags = lookup_flags (prefer_type, namespaces_only);
5914       /* If we're not parsing, we need to complain. */
5915       flags |= LOOKUP_COMPLAIN;
5916     }
5917
5918   /* First, look in non-namespace scopes.  */
5919
5920   if (current_class_type == NULL_TREE)
5921     nonclass = 1;
5922
5923   for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
5924     {
5925       tree binding;
5926
5927       if (!LOCAL_BINDING_P (t) && nonclass)
5928         /* We're not looking for class-scoped bindings, so keep going.  */
5929         continue;
5930
5931       /* If this is the kind of thing we're looking for, we're done.  */
5932       if (qualify_lookup (BINDING_VALUE (t), flags))
5933         binding = BINDING_VALUE (t);
5934       else if ((flags & LOOKUP_PREFER_TYPES)
5935                && qualify_lookup (BINDING_TYPE (t), flags))
5936         binding = BINDING_TYPE (t);
5937       else
5938         binding = NULL_TREE;
5939
5940       /* Handle access control on types from enclosing or base classes.  */
5941       if (binding && ! yylex
5942           && BINDING_LEVEL (t) && BINDING_LEVEL (t)->parm_flag == 2)
5943         type_access_control (BINDING_LEVEL (t)->this_class, binding);
5944
5945       if (binding
5946           && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
5947         {
5948           if (val_is_implicit_typename && !yylex)
5949             warn_about_implicit_typename_lookup (val, binding);
5950           val = binding;
5951           val_is_implicit_typename
5952             = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
5953           if (!val_is_implicit_typename)
5954             break;
5955         }
5956     }
5957
5958   /* Now lookup in namespace scopes.  */
5959   if (!val || val_is_implicit_typename)
5960     {
5961       t = unqualified_namespace_lookup (name, flags, 0);
5962       if (t)
5963         {
5964           if (val_is_implicit_typename && !yylex)
5965             warn_about_implicit_typename_lookup (val, t);
5966           val = t;
5967         }
5968     }
5969
5970  done:
5971   if (val)
5972     {
5973       /* This should only warn about types used in qualified-ids.  */
5974       if (from_obj && from_obj != val)
5975         {
5976           if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
5977               && TREE_CODE (val) == TYPE_DECL
5978               && TREE_TYPE (from_obj) != TREE_TYPE (val))
5979             {
5980               cp_pedwarn ("lookup of `%D' in the scope of `%#T' (`%#T')",
5981                           name, got_object, TREE_TYPE (from_obj));
5982               cp_pedwarn ("  does not match lookup in the current scope (`%#T')",
5983                           TREE_TYPE (val));
5984             }
5985
5986           /* We don't change val to from_obj if got_object depends on
5987              template parms because that breaks implicit typename for
5988              destructor calls.  */
5989           if (! uses_template_parms (got_object))
5990             val = from_obj;
5991         }
5992
5993       /* If we have a single function from a using decl, pull it out.  */
5994       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5995         val = OVL_FUNCTION (val);
5996     }
5997   else if (from_obj)
5998     val = from_obj;
5999
6000   return val;
6001 }
6002
6003 tree
6004 lookup_name_nonclass (name)
6005      tree name;
6006 {
6007   return lookup_name_real (name, 0, 1, 0);
6008 }
6009
6010 tree
6011 lookup_function_nonclass (name, args)
6012      tree name;
6013      tree args;
6014 {
6015   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
6016 }
6017
6018 tree
6019 lookup_name_namespace_only (name)
6020      tree name;
6021 {
6022   /* type-or-namespace, nonclass, namespace_only */
6023   return lookup_name_real (name, 1, 1, 1);
6024 }
6025
6026 tree
6027 lookup_name (name, prefer_type)
6028      tree name;
6029      int prefer_type;
6030 {
6031   return lookup_name_real (name, prefer_type, 0, 0);
6032 }
6033
6034 /* Similar to `lookup_name' but look only in the innermost non-class
6035    binding level.  */
6036
6037 tree
6038 lookup_name_current_level (name)
6039      tree name;
6040 {
6041   struct binding_level *b;
6042   tree t = NULL_TREE;
6043
6044   b = current_binding_level;
6045   while (b->parm_flag == 2)
6046     b = b->level_chain;
6047
6048   if (b->namespace_p)
6049     {
6050       t = IDENTIFIER_NAMESPACE_VALUE (name);
6051
6052       /* extern "C" function() */
6053       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
6054         t = TREE_VALUE (t);
6055     }
6056   else if (IDENTIFIER_BINDING (name)
6057            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
6058     {
6059       while (1)
6060         {
6061           if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
6062             return IDENTIFIER_VALUE (name);
6063
6064           if (b->keep == 2)
6065             b = b->level_chain;
6066           else
6067             break;
6068         }
6069     }
6070
6071   return t;
6072 }
6073
6074 /* Like lookup_name_current_level, but for types.  */
6075
6076 tree
6077 lookup_type_current_level (name)
6078      tree name;
6079 {
6080   register tree t = NULL_TREE;
6081
6082   my_friendly_assert (! current_binding_level->namespace_p, 980716);
6083
6084   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
6085       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
6086     {
6087       struct binding_level *b = current_binding_level;
6088       while (1)
6089         {
6090           if (purpose_member (name, b->type_shadowed))
6091             return REAL_IDENTIFIER_TYPE_VALUE (name);
6092           if (b->keep == 2)
6093             b = b->level_chain;
6094           else
6095             break;
6096         }
6097     }
6098
6099   return t;
6100 }
6101
6102 void
6103 begin_only_namespace_names ()
6104 {
6105   only_namespace_names = 1;
6106 }
6107
6108 void
6109 end_only_namespace_names ()
6110 {
6111   only_namespace_names = 0;
6112 }
6113 \f
6114 /* Push the declarations of builtin types into the namespace.
6115    RID_INDEX, if < CP_RID_MAX is the index of the builtin type
6116    in the array RID_POINTERS.  NAME is the name used when looking
6117    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
6118
6119 static void
6120 record_builtin_type (rid_index, name, type)
6121      enum rid rid_index;
6122      const char *name;
6123      tree type;
6124 {
6125   tree rname = NULL_TREE, tname = NULL_TREE;
6126   tree tdecl = NULL_TREE;
6127
6128   if ((int) rid_index < (int) CP_RID_MAX)
6129     rname = ridpointers[(int) rid_index];
6130   if (name)
6131     tname = get_identifier (name);
6132
6133   TYPE_BUILT_IN (type) = 1;
6134
6135   if (tname)
6136     {
6137       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
6138       set_identifier_type_value (tname, NULL_TREE);
6139       if ((int) rid_index < (int) CP_RID_MAX)
6140         /* Built-in types live in the global namespace. */
6141         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
6142     }
6143   if (rname != NULL_TREE)
6144     {
6145       if (tname != NULL_TREE)
6146         {
6147           set_identifier_type_value (rname, NULL_TREE);
6148           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
6149         }
6150       else
6151         {
6152           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
6153           set_identifier_type_value (rname, NULL_TREE);
6154         }
6155     }
6156 }
6157
6158 /* Record one of the standard Java types.
6159  * Declare it as having the given NAME.
6160  * If SIZE > 0, it is the size of one of the integral types;
6161  * otherwise it is the negative of the size of one of the other types.  */
6162
6163 static tree
6164 record_builtin_java_type (name, size)
6165      const char *name;
6166      int size;
6167 {
6168   tree type, decl;
6169   if (size > 0)
6170     type = make_signed_type (size);
6171   else if (size > -32)
6172     { /* "__java_char" or ""__java_boolean". */
6173       type = make_unsigned_type (-size);
6174       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6175     }
6176   else
6177     { /* "__java_float" or ""__java_double". */
6178       type = make_node (REAL_TYPE);
6179       TYPE_PRECISION (type) = - size;
6180       layout_type (type);
6181     }
6182   record_builtin_type (CP_RID_MAX, name, type);
6183   decl = TYPE_NAME (type);
6184
6185   /* Suppress generate debug symbol entries for these types,
6186      since for normal C++ they are just clutter.
6187      However, push_lang_context undoes this if extern "Java" is seen. */
6188   DECL_IGNORED_P (decl) = 1;
6189
6190   TYPE_FOR_JAVA (type) = 1;
6191   return type;
6192 }
6193
6194 /* Push a type into the namespace so that the back-ends ignore it. */
6195
6196 static void
6197 record_unknown_type (type, name)
6198      tree type;
6199      const char *name;
6200 {
6201   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
6202   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
6203   DECL_IGNORED_P (decl) = 1;
6204   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6205   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
6206   TYPE_ALIGN (type) = 1;
6207   TYPE_USER_ALIGN (type) = 0;
6208   TYPE_MODE (type) = TYPE_MODE (void_type_node);
6209 }
6210
6211 /* An string for which we should create an IDENTIFIER_NODE at
6212    startup.  */
6213
6214 typedef struct predefined_identifier
6215 {
6216   /* The name of the identifier.  */
6217   const char *name;
6218   /* The place where the IDENTIFIER_NODE should be stored.  */
6219   tree *node;
6220   /* Non-zero if this is the name of a constructor or destructor.  */
6221   int ctor_or_dtor_p;
6222 } predefined_identifier;
6223
6224 /* Create all the predefined identifiers.  */
6225
6226 static void
6227 initialize_predefined_identifiers ()
6228 {
6229   struct predefined_identifier *pid;
6230
6231   /* A table of identifiers to create at startup.  */
6232   static predefined_identifier predefined_identifiers[] = {
6233     { "C++", &lang_name_cplusplus, 0 },
6234     { "C", &lang_name_c, 0 },
6235     { "Java", &lang_name_java, 0 },
6236     { CTOR_NAME, &ctor_identifier, 1 },
6237     { "__base_ctor", &base_ctor_identifier, 1 },
6238     { "__comp_ctor", &complete_ctor_identifier, 1 },
6239     { DTOR_NAME, &dtor_identifier, 1 },
6240     { "__comp_dtor", &complete_dtor_identifier, 1 },
6241     { "__base_dtor", &base_dtor_identifier, 1 },
6242     { "__deleting_dtor", &deleting_dtor_identifier, 1 },
6243     { VTABLE_DELTA2_NAME, &delta2_identifier, 0 },
6244     { VTABLE_DELTA_NAME, &delta_identifier, 0 },
6245     { IN_CHARGE_NAME, &in_charge_identifier, 0 },
6246     { VTABLE_INDEX_NAME, &index_identifier, 0 },
6247     { "nelts", &nelts_identifier, 0 },
6248     { THIS_NAME, &this_identifier, 0 },
6249     { VTABLE_PFN_NAME, &pfn_identifier, 0 },
6250     { "__pfn_or_delta2", &pfn_or_delta2_identifier, 0 },
6251     { "_vptr", &vptr_identifier, 0 },
6252     { "__cp_push_exception", &cp_push_exception_identifier, 0 },
6253     { "__vtt_parm", &vtt_parm_identifier, 0 },
6254     { "std", &std_identifier, 0 },
6255     { NULL, NULL, 0 }
6256   };
6257
6258   for (pid = predefined_identifiers; pid->name; ++pid)
6259     {
6260       *pid->node = get_identifier (pid->name);
6261       if (pid->ctor_or_dtor_p)
6262         IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
6263     }
6264 }
6265
6266 /* Create the predefined scalar types of C,
6267    and some nodes representing standard constants (0, 1, (void *)0).
6268    Initialize the global binding level.
6269    Make definitions for built-in primitive functions.  */
6270
6271 void
6272 init_decl_processing ()
6273 {
6274   tree fields[20];
6275   int wchar_type_size;
6276   tree array_domain_type;
6277
6278   /* Check to see that the user did not specify an invalid combination
6279      of command-line options.  */
6280   if (flag_new_abi && !flag_vtable_thunks)
6281     fatal ("the new ABI requires vtable thunks");
6282
6283   /* Create all the identifiers we need.  */
6284   initialize_predefined_identifiers ();
6285
6286   /* Let the back-end now how to save and restore language-specific
6287      per-function globals.  */
6288   init_lang_status = &push_cp_function_context;
6289   free_lang_status = &pop_cp_function_context;
6290   mark_lang_status = &mark_cp_function_context;
6291
6292   cp_parse_init ();
6293   init_decl2 ();
6294   init_pt ();
6295
6296   /* Create the global variables.  */
6297   push_to_top_level ();
6298
6299   /* Enter the global namespace. */
6300   my_friendly_assert (global_namespace == NULL_TREE, 375);
6301   push_namespace (get_identifier ("::"));
6302   global_namespace = current_namespace;
6303   current_lang_name = NULL_TREE;
6304
6305   /* Adjust various flags based on command-line settings.  */
6306   if (! flag_permissive && ! pedantic)
6307     flag_pedantic_errors = 1;
6308   if (!flag_no_inline)
6309     flag_inline_trees = 1;
6310
6311   /* Initially, C.  */
6312   current_lang_name = lang_name_c;
6313
6314   current_function_decl = NULL_TREE;
6315   current_binding_level = NULL_BINDING_LEVEL;
6316   free_binding_level = NULL_BINDING_LEVEL;
6317
6318   build_common_tree_nodes (flag_signed_char);
6319
6320   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6321   TREE_TYPE (error_mark_list) = error_mark_node;
6322
6323   /* Make the binding_level structure for global names.  */
6324   pushlevel (0);
6325   global_binding_level = current_binding_level;
6326   /* The global level is the namespace level of ::.  */
6327   NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6328   declare_namespace_level ();
6329
6330   /* Define `int' and `char' first so that dbx will output them first.  */
6331   record_builtin_type (RID_INT, NULL_PTR, integer_type_node);
6332   record_builtin_type (RID_CHAR, "char", char_type_node);
6333
6334   /* `signed' is the same as `int' */
6335   record_builtin_type (RID_SIGNED, NULL_PTR, integer_type_node);
6336   record_builtin_type (RID_LONG, "long int", long_integer_type_node);
6337   record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
6338   record_builtin_type (CP_RID_MAX, "long unsigned int",
6339                        long_unsigned_type_node);
6340   record_builtin_type (CP_RID_MAX, "unsigned long", long_unsigned_type_node);
6341   record_builtin_type (CP_RID_MAX, "long long int",
6342                        long_long_integer_type_node);
6343   record_builtin_type (CP_RID_MAX, "long long unsigned int",
6344                        long_long_unsigned_type_node);
6345   record_builtin_type (CP_RID_MAX, "long long unsigned",
6346                        long_long_unsigned_type_node);
6347   record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
6348   record_builtin_type (CP_RID_MAX, "short unsigned int",
6349                        short_unsigned_type_node);
6350   record_builtin_type (CP_RID_MAX, "unsigned short",
6351                        short_unsigned_type_node);
6352
6353   ptrdiff_type_node
6354     = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE)));
6355
6356   /* Define both `signed char' and `unsigned char'.  */
6357   record_builtin_type (CP_RID_MAX, "signed char", signed_char_type_node);
6358   record_builtin_type (CP_RID_MAX, "unsigned char", unsigned_char_type_node);
6359
6360   /* `unsigned long' is the standard type for sizeof.
6361      Note that stddef.h uses `unsigned long',
6362      and this must agree, even if long and int are the same size.  */
6363   set_sizetype
6364     (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE))));
6365
6366   /* Create the widest literal types. */
6367   widest_integer_literal_type_node = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
6368   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6369                         widest_integer_literal_type_node));
6370
6371   widest_unsigned_literal_type_node = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
6372   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6373                         widest_unsigned_literal_type_node));
6374
6375   /* These are types that type_for_size and type_for_mode use.  */
6376   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
6377   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
6378   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
6379   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
6380 #if HOST_BITS_PER_WIDE_INT >= 64
6381   pushdecl (build_decl (TYPE_DECL, get_identifier ("__int128_t"), intTI_type_node));
6382 #endif
6383   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
6384   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
6385   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
6386   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
6387 #if HOST_BITS_PER_WIDE_INT >= 64
6388   pushdecl (build_decl (TYPE_DECL, get_identifier ("__uint128_t"), unsigned_intTI_type_node));
6389 #endif
6390
6391   build_common_tree_nodes_2 (flag_short_double);
6392
6393   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6394   java_short_type_node = record_builtin_java_type ("__java_short", 16);
6395   java_int_type_node = record_builtin_java_type ("__java_int", 32);
6396   java_long_type_node = record_builtin_java_type ("__java_long", 64);
6397   java_float_type_node = record_builtin_java_type ("__java_float", -32);
6398   java_double_type_node = record_builtin_java_type ("__java_double", -64);
6399   java_char_type_node = record_builtin_java_type ("__java_char", -16);
6400   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6401
6402   integer_two_node = build_int_2 (2, 0);
6403   TREE_TYPE (integer_two_node) = integer_type_node;
6404   integer_three_node = build_int_2 (3, 0);
6405   TREE_TYPE (integer_three_node) = integer_type_node;
6406
6407   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6408   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6409   TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6410   TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6411   TYPE_PRECISION (boolean_type_node) = 1;
6412   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6413   boolean_false_node = build_int_2 (0, 0);
6414   TREE_TYPE (boolean_false_node) = boolean_type_node;
6415   boolean_true_node = build_int_2 (1, 0);
6416   TREE_TYPE (boolean_true_node) = boolean_type_node;
6417
6418   signed_size_zero_node = build_int_2 (0, 0);
6419   record_builtin_type (RID_FLOAT, NULL_PTR, float_type_node);
6420   record_builtin_type (RID_DOUBLE, NULL_PTR, double_type_node);
6421   record_builtin_type (CP_RID_MAX, "long double", long_double_type_node);
6422
6423   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
6424                         complex_integer_type_node));
6425   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
6426                         complex_float_type_node));
6427   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),
6428                         complex_double_type_node));
6429   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
6430                         complex_long_double_type_node));
6431
6432   TREE_TYPE (signed_size_zero_node) = make_signed_type (TYPE_PRECISION (sizetype));
6433
6434   record_builtin_type (RID_VOID, NULL_PTR, void_type_node);
6435   void_list_node = build_tree_list (NULL_TREE, void_type_node);
6436   TREE_PARMLIST (void_list_node) = 1;
6437
6438   /* Used for expressions that do nothing, but are not errors.  */
6439   void_zero_node = build_int_2 (0, 0);
6440   TREE_TYPE (void_zero_node) = void_type_node;
6441
6442   string_type_node = build_pointer_type (char_type_node);
6443   const_string_type_node
6444     = build_pointer_type (build_qualified_type (char_type_node,
6445                                                 TYPE_QUAL_CONST));
6446   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6447 #if 0
6448   record_builtin_type (CP_RID_MAX, NULL_PTR, string_type_node);
6449 #endif
6450
6451   /* Make a type to be the domain of a few array types
6452      whose domains don't really matter.
6453      200 is small enough that it always fits in size_t.  */
6454   array_domain_type = build_index_type (build_int_2 (200, 0));
6455
6456   /* Make a type for arrays of characters.
6457      With luck nothing will ever really depend on the length of this
6458      array type.  */
6459   char_array_type_node
6460     = build_array_type (char_type_node, array_domain_type);
6461
6462   /* Likewise for arrays of ints.  */
6463   int_array_type_node
6464     = build_array_type (integer_type_node, array_domain_type);
6465
6466   if (flag_new_abi)
6467     delta_type_node = ptrdiff_type_node;
6468   else if (flag_huge_objects)
6469     delta_type_node = long_integer_type_node;
6470   else
6471     delta_type_node = short_integer_type_node;
6472
6473   if (flag_new_abi)
6474     vtable_index_type = ptrdiff_type_node;
6475   else
6476     vtable_index_type = delta_type_node;
6477
6478   default_function_type
6479     = build_function_type (integer_type_node, NULL_TREE);
6480
6481   ptr_type_node = build_pointer_type (void_type_node);
6482   const_ptr_type_node
6483     = build_pointer_type (build_qualified_type (void_type_node,
6484                                                 TYPE_QUAL_CONST));
6485   vtt_parm_type = build_pointer_type (const_ptr_type_node);
6486   c_common_nodes_and_builtins (1, flag_no_builtin, flag_no_nonansi_builtin);
6487   lang_type_promotes_to = convert_type_from_ellipsis;
6488
6489   void_ftype_ptr
6490     = build_exception_variant (void_ftype_ptr, empty_except_spec);
6491
6492   /* C++ extensions */
6493
6494   unknown_type_node = make_node (UNKNOWN_TYPE);
6495   record_unknown_type (unknown_type_node, "unknown type");
6496
6497   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
6498   TREE_TYPE (unknown_type_node) = unknown_type_node;
6499
6500   TREE_TYPE (null_node) = type_for_size (POINTER_SIZE, 0);
6501
6502   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6503      result.  */
6504   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6505   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6506
6507   /* This is special for C++ so functions can be overloaded.  */
6508   wchar_type_node = get_identifier (flag_short_wchar
6509                                     ? "short unsigned int"
6510                                     : WCHAR_TYPE);
6511   wchar_type_node = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (wchar_type_node));
6512   wchar_type_size = TYPE_PRECISION (wchar_type_node);
6513   if (TREE_UNSIGNED (wchar_type_node))
6514     wchar_type_node = make_signed_type (wchar_type_size);
6515   else
6516     wchar_type_node = make_unsigned_type (wchar_type_size);
6517   record_builtin_type (RID_WCHAR, "__wchar_t", wchar_type_node);
6518
6519   /* Artificial declaration of wchar_t -- can be bashed */
6520   wchar_decl_node = build_decl (TYPE_DECL, get_identifier ("wchar_t"),
6521                                 wchar_type_node);
6522   pushdecl (wchar_decl_node);
6523
6524   /* This is for wide string constants.  */
6525   wchar_array_type_node
6526     = build_array_type (wchar_type_node, array_domain_type);
6527
6528   if (flag_vtable_thunks)
6529     {
6530       /* Make sure we get a unique function type, so we can give
6531          its pointer type a name.  (This wins for gdb.) */
6532       tree vfunc_type = make_node (FUNCTION_TYPE);
6533       TREE_TYPE (vfunc_type) = integer_type_node;
6534       TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6535       layout_type (vfunc_type);
6536
6537       vtable_entry_type = build_pointer_type (vfunc_type);
6538     }
6539   else
6540     {
6541       vtable_entry_type = make_aggr_type (RECORD_TYPE);
6542       fields[0] = build_decl (FIELD_DECL, delta_identifier,
6543                               delta_type_node);
6544       fields[1] = build_decl (FIELD_DECL, index_identifier,
6545                               delta_type_node);
6546       fields[2] = build_decl (FIELD_DECL, pfn_identifier,
6547                               ptr_type_node);
6548       finish_builtin_type (vtable_entry_type, VTBL_PTR_TYPE, fields, 2,
6549                            double_type_node);
6550
6551       /* Make this part of an invisible union.  */
6552       fields[3] = copy_node (fields[2]);
6553       TREE_TYPE (fields[3]) = delta_type_node;
6554       DECL_NAME (fields[3]) = delta2_identifier;
6555       DECL_MODE (fields[3]) = TYPE_MODE (delta_type_node);
6556       DECL_SIZE (fields[3]) = TYPE_SIZE (delta_type_node);
6557       DECL_SIZE_UNIT (fields[3]) = TYPE_SIZE_UNIT (delta_type_node);
6558       TREE_UNSIGNED (fields[3]) = 0;
6559       TREE_CHAIN (fields[2]) = fields[3];
6560       vtable_entry_type = build_qualified_type (vtable_entry_type,
6561                                                 TYPE_QUAL_CONST);
6562     }
6563   record_builtin_type (CP_RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6564
6565   vtbl_type_node
6566     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6567   layout_type (vtbl_type_node);
6568   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6569   record_builtin_type (CP_RID_MAX, NULL_PTR, vtbl_type_node);
6570   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6571   layout_type (vtbl_ptr_type_node);
6572   record_builtin_type (CP_RID_MAX, NULL_PTR, vtbl_ptr_type_node);
6573
6574   std_node = build_decl (NAMESPACE_DECL,
6575                          flag_honor_std
6576                          ? get_identifier ("fake std") : std_identifier,
6577                          void_type_node);
6578   pushdecl (std_node);
6579
6580   if (flag_new_abi)
6581     {
6582       push_namespace (get_identifier ("__cxxabiv1"));
6583       abi_node = current_namespace;
6584       pop_namespace ();
6585     }
6586
6587   global_type_node = make_node (LANG_TYPE);
6588   record_unknown_type (global_type_node, "global type");
6589
6590   /* Now, C++.  */
6591   current_lang_name = lang_name_cplusplus;
6592
6593   {
6594     tree bad_alloc_type_node, newtype, deltype;
6595     if (flag_honor_std)
6596       push_namespace (get_identifier ("std"));
6597     bad_alloc_type_node = xref_tag
6598       (class_type_node, get_identifier ("bad_alloc"), 1);
6599     if (flag_honor_std)
6600       pop_namespace ();
6601     newtype = build_exception_variant
6602       (ptr_ftype_sizetype, add_exception_specifier (NULL_TREE, bad_alloc_type_node, -1));
6603     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6604     push_cp_library_fn (NEW_EXPR, newtype);
6605     push_cp_library_fn (VEC_NEW_EXPR, newtype);
6606     global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
6607     push_cp_library_fn (VEC_DELETE_EXPR, deltype);
6608   }
6609
6610   abort_fndecl
6611     = build_library_fn_ptr ("__pure_virtual", void_ftype);
6612
6613   /* Perform other language dependent initializations.  */
6614   init_class_processing ();
6615   init_init_processing ();
6616   init_search_processing ();
6617   init_rtti_processing ();
6618
6619   if (flag_exceptions)
6620     init_exception_processing ();
6621   if (flag_no_inline)
6622     {
6623       flag_inline_functions = 0;
6624     }
6625
6626   if (! supports_one_only ())
6627     flag_weak = 0;
6628
6629   /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__.  */
6630   make_fname_decl = cp_make_fname_decl;
6631   declare_function_name ();
6632
6633   /* Prepare to check format strings against argument lists.  */
6634   init_function_format_info ();
6635
6636   /* Show we use EH for cleanups.  */
6637   using_eh_for_cleanups ();
6638
6639   print_error_function = lang_print_error_function;
6640   valid_lang_attribute = cp_valid_lang_attribute;
6641
6642   /* Maintain consistency.  Perhaps we should just complain if they
6643      say -fwritable-strings?  */
6644   if (flag_writable_strings)
6645     flag_const_strings = 0;
6646
6647   /* Add GC roots for all of our global variables.  */
6648   ggc_add_tree_root (c_global_trees, sizeof c_global_trees / sizeof(tree));
6649   ggc_add_tree_root (cp_global_trees, sizeof cp_global_trees / sizeof(tree));
6650   ggc_add_tree_root (&integer_three_node, 1);
6651   ggc_add_tree_root (&integer_two_node, 1);
6652   ggc_add_tree_root (&signed_size_zero_node, 1);
6653   ggc_add_tree_root (&size_one_node, 1);
6654   ggc_add_tree_root (&size_zero_node, 1);
6655   ggc_add_root (&global_binding_level, 1, sizeof global_binding_level,
6656                 mark_binding_level);
6657   ggc_add_root (&scope_chain, 1, sizeof scope_chain, &mark_saved_scope);
6658   ggc_add_tree_root (&static_ctors, 1);
6659   ggc_add_tree_root (&static_dtors, 1);
6660   ggc_add_tree_root (&lastiddecl, 1);
6661
6662   ggc_add_tree_root (&last_function_parm_tags, 1);
6663   ggc_add_tree_root (&current_function_return_value, 1);
6664   ggc_add_tree_root (&current_function_parms, 1);
6665   ggc_add_tree_root (&current_function_parm_tags, 1);
6666   ggc_add_tree_root (&last_function_parms, 1);
6667   ggc_add_tree_root (&error_mark_list, 1);
6668
6669   ggc_add_tree_root (&global_namespace, 1);
6670   ggc_add_tree_root (&global_type_node, 1);
6671   ggc_add_tree_root (&anonymous_namespace_name, 1);
6672
6673   ggc_add_tree_root (&got_object, 1);
6674   ggc_add_tree_root (&got_scope, 1);
6675
6676   ggc_add_tree_root (&current_lang_name, 1);
6677   ggc_add_tree_root (&static_aggregates, 1);
6678 }
6679
6680 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6681    decl, NAME is the initialization string and TYPE_DEP indicates whether
6682    NAME depended on the type of the function. We make use of that to detect
6683    __PRETTY_FUNCTION__ inside a template fn.  Because we build a tree for
6684    the function before emitting any of it, we don't need to treat the
6685    VAR_DECL specially. We can decide whether to emit it later, if it was
6686    used.  */
6687
6688 static tree
6689 cp_make_fname_decl (id, name, type_dep)
6690      tree id;
6691      const char *name;
6692      int type_dep;
6693 {
6694   tree decl, type, init;
6695   size_t length = strlen (name);
6696   tree domain = NULL_TREE;
6697
6698   if (!processing_template_decl)
6699     type_dep = 0;
6700   if (!type_dep)
6701     domain = build_index_type (build_int_2 (length, 0));
6702
6703   type =  build_cplus_array_type
6704           (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
6705            domain);
6706
6707   decl = build_decl (VAR_DECL, id, type);
6708   TREE_STATIC (decl) = 1;
6709   TREE_READONLY (decl) = 1;
6710   DECL_SOURCE_LINE (decl) = 0;
6711   DECL_ARTIFICIAL (decl) = 1;
6712   DECL_IN_SYSTEM_HEADER (decl) = 1;
6713   pushdecl (decl);
6714   if (processing_template_decl)
6715     decl = push_template_decl (decl);
6716   if (type_dep)
6717     {
6718       init = build (FUNCTION_NAME, type);
6719       DECL_PRETTY_FUNCTION_P (decl) = 1;
6720     }
6721   else
6722     {
6723       init = build_string (length + 1, name);
6724       TREE_TYPE (init) = type;
6725     }
6726   DECL_INITIAL (decl) = init;
6727   cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
6728
6729   /* We will have to make sure we only emit this, if it is actually used. */
6730   return decl;
6731 }
6732
6733 /* Function to print any language-specific context for an error message.  */
6734
6735 static void
6736 lang_print_error_function (file)
6737      const char *file;
6738 {
6739   default_print_error_function (file);
6740   maybe_print_template_context ();
6741 }
6742
6743 /* Entry point for the benefit of c_common_nodes_and_builtins.
6744
6745    Make a definition for a builtin function named NAME and whose data type
6746    is TYPE.  TYPE should be a function type with argument types.
6747
6748    CLASS and CODE tell later passes how to compile calls to this function.
6749    See tree.h for possible values.
6750
6751    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6752    the name to be called if we can't opencode the function.  */
6753
6754 tree
6755 builtin_function (name, type, code, class, libname)
6756      const char *name;
6757      tree type;
6758      int code;
6759      enum built_in_class class;
6760      const char *libname;
6761 {
6762   tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
6763   DECL_BUILT_IN_CLASS (decl) = class;
6764   DECL_FUNCTION_CODE (decl) = code;
6765
6766   my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 392);
6767
6768   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6769      we cannot change DECL_ASSEMBLER_NAME until we have installed this
6770      function in the namespace.  */
6771   pushdecl (decl);
6772   if (libname)
6773     DECL_ASSEMBLER_NAME (decl) = get_identifier (libname);
6774   make_function_rtl (decl);
6775
6776   /* Warn if a function in the namespace for users
6777      is used without an occasion to consider it declared.  */
6778   if (name[0] != '_' || name[1] != '_')
6779     DECL_ANTICIPATED (decl) = 1;
6780
6781   return decl;
6782 }
6783
6784 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
6785    function.  Not called directly.  */
6786
6787 static tree
6788 build_library_fn_1 (name, operator_code, type)
6789      tree name;
6790      enum tree_code operator_code;
6791      tree type;
6792 {
6793   tree fn = build_lang_decl (FUNCTION_DECL, name, type);
6794   DECL_EXTERNAL (fn) = 1;
6795   TREE_PUBLIC (fn) = 1;
6796   DECL_ARTIFICIAL (fn) = 1;
6797   TREE_NOTHROW (fn) = 1;
6798   SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
6799   return fn;
6800 }
6801
6802 /* Returns the _DECL for a library function with C linkage.
6803    We assume that such functions never throw; if this is incorrect,
6804    callers should unset TREE_NOTHROW.  */
6805
6806 tree
6807 build_library_fn (name, type)
6808      tree name;
6809      tree type;
6810 {
6811   tree fn = build_library_fn_1 (name, ERROR_MARK, type);
6812   make_function_rtl (fn);
6813   return fn;
6814 }
6815
6816 /* Returns the _DECL for a library function with C++ linkage.  */
6817
6818 static tree
6819 build_cp_library_fn (name, operator_code, type)
6820      tree name;
6821      enum tree_code operator_code;
6822      tree type;
6823 {
6824   tree fn = build_library_fn_1 (name, operator_code, type);
6825   TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
6826   DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
6827   set_mangled_name_for_decl (fn);
6828   make_function_rtl (fn);
6829   return fn;
6830 }
6831
6832 /* Like build_library_fn, but takes a C string instead of an
6833    IDENTIFIER_NODE.  */
6834
6835 tree
6836 build_library_fn_ptr (name, type)
6837      const char *name;
6838      tree type;
6839 {
6840   return build_library_fn (get_identifier (name), type);
6841 }
6842
6843 /* Like build_cp_library_fn, but takes a C string instead of an
6844    IDENTIFIER_NODE.  */
6845
6846 tree
6847 build_cp_library_fn_ptr (name, type)
6848      const char *name;
6849      tree type;
6850 {
6851   return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
6852 }
6853
6854 /* Like build_library_fn, but also pushes the function so that we will
6855    be able to find it via IDENTIFIER_GLOBAL_VALUE.  */
6856
6857 tree
6858 push_library_fn (name, type)
6859      tree name, type;
6860 {
6861   tree fn = build_library_fn (name, type);
6862   pushdecl_top_level (fn);
6863   return fn;
6864 }
6865
6866 /* Like build_cp_library_fn, but also pushes the function so that it
6867    will be found by normal lookup.  */
6868
6869 static tree
6870 push_cp_library_fn (operator_code, type)
6871      enum tree_code operator_code;
6872      tree type;
6873 {
6874   tree fn = build_cp_library_fn (ansi_opname (operator_code),
6875                                  operator_code,
6876                                  type);
6877   pushdecl (fn);
6878   return fn;
6879 }
6880
6881 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
6882    a FUNCTION_TYPE.  */
6883
6884 tree
6885 push_void_library_fn (name, parmtypes)
6886      tree name, parmtypes;
6887 {
6888   tree type = build_function_type (void_type_node, parmtypes);
6889   return push_library_fn (name, type);
6890 }
6891
6892 /* Like push_library_fn, but also note that this function throws
6893    and does not return.  Used for __throw_foo and the like.  */
6894
6895 tree
6896 push_throw_library_fn (name, type)
6897      tree name, type;
6898 {
6899   tree fn = push_library_fn (name, type);
6900   TREE_THIS_VOLATILE (fn) = 1;
6901   TREE_NOTHROW (fn) = 0;
6902   return fn;
6903 }
6904 \f
6905 /* When we call finish_struct for an anonymous union, we create
6906    default copy constructors and such.  But, an anonymous union
6907    shouldn't have such things; this function undoes the damage to the
6908    anonymous union type T.
6909
6910    (The reason that we create the synthesized methods is that we don't
6911    distinguish `union { int i; }' from `typedef union { int i; } U'.
6912    The first is an anonymous union; the second is just an ordinary
6913    union type.)  */
6914
6915 void
6916 fixup_anonymous_aggr (t)
6917      tree t;
6918 {
6919   tree *q;
6920
6921   /* Wipe out memory of synthesized methods */
6922   TYPE_HAS_CONSTRUCTOR (t) = 0;
6923   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6924   TYPE_HAS_INIT_REF (t) = 0;
6925   TYPE_HAS_CONST_INIT_REF (t) = 0;
6926   TYPE_HAS_ASSIGN_REF (t) = 0;
6927   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6928
6929   /* Splice the implicitly generated functions out of the TYPE_METHODS
6930      list.  */
6931   q = &TYPE_METHODS (t);
6932   while (*q)
6933     {
6934       if (DECL_ARTIFICIAL (*q))
6935         *q = TREE_CHAIN (*q);
6936       else
6937         q = &TREE_CHAIN (*q);
6938     }
6939
6940   /* ISO C++ 9.5.3.  Anonymous unions may not have function members.  */
6941   if (TYPE_METHODS (t))
6942     error ("an anonymous union cannot have function members");
6943 }
6944
6945 /* Make sure that a declaration with no declarator is well-formed, i.e.
6946    just defines a tagged type or anonymous union.
6947
6948    Returns the type defined, if any.  */
6949
6950 tree
6951 check_tag_decl (declspecs)
6952      tree declspecs;
6953 {
6954   int found_type = 0;
6955   int saw_friend = 0;
6956   tree ob_modifier = NULL_TREE;
6957   register tree link;
6958   register tree t = NULL_TREE;
6959
6960   for (link = declspecs; link; link = TREE_CHAIN (link))
6961     {
6962       register tree value = TREE_VALUE (link);
6963
6964       if (TYPE_P (value)
6965           || (TREE_CODE (value) == IDENTIFIER_NODE
6966               && IDENTIFIER_GLOBAL_VALUE (value)
6967               && TYPE_P (IDENTIFIER_GLOBAL_VALUE (value))))
6968         {
6969           ++found_type;
6970
6971           if (IS_AGGR_TYPE (value) || TREE_CODE (value) == ENUMERAL_TYPE)
6972             {
6973               my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
6974               t = value;
6975             }
6976         }
6977       else if (value == ridpointers[(int) RID_FRIEND])
6978         {
6979           if (current_class_type == NULL_TREE
6980               || current_scope () != current_class_type)
6981             ob_modifier = value;
6982           else
6983             saw_friend = 1;
6984         }
6985       else if (value == ridpointers[(int) RID_STATIC]
6986                || value == ridpointers[(int) RID_EXTERN]
6987                || value == ridpointers[(int) RID_AUTO]
6988                || value == ridpointers[(int) RID_REGISTER]
6989                || value == ridpointers[(int) RID_INLINE]
6990                || value == ridpointers[(int) RID_VIRTUAL]
6991                || value == ridpointers[(int) RID_CONST]
6992                || value == ridpointers[(int) RID_VOLATILE]
6993                || value == ridpointers[(int) RID_EXPLICIT])
6994         ob_modifier = value;
6995     }
6996
6997   if (found_type > 1)
6998     error ("multiple types in one declaration");
6999
7000   if (t == NULL_TREE && ! saw_friend)
7001     pedwarn ("declaration does not declare anything");
7002
7003   /* Check for an anonymous union.  We're careful
7004      accessing TYPE_IDENTIFIER because some built-in types, like
7005      pointer-to-member types, do not have TYPE_NAME.  */
7006   else if (t && IS_AGGR_TYPE_CODE (TREE_CODE (t))
7007            && TYPE_NAME (t)
7008            && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
7009     {
7010       /* Anonymous unions are objects, so they can have specifiers.  */;
7011       SET_ANON_AGGR_TYPE_P (t);
7012
7013       if (TREE_CODE (t) != UNION_TYPE && pedantic && ! in_system_header)
7014         pedwarn ("ISO C++ prohibits anonymous structs");
7015     }
7016
7017   else if (ob_modifier)
7018     {
7019       if (ob_modifier == ridpointers[(int) RID_INLINE]
7020           || ob_modifier == ridpointers[(int) RID_VIRTUAL])
7021         cp_error ("`%D' can only be specified for functions", ob_modifier);
7022       else if (ob_modifier == ridpointers[(int) RID_FRIEND])
7023         cp_error ("`%D' can only be specified inside a class", ob_modifier);
7024       else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
7025         cp_error ("`%D' can only be specified for constructors",
7026                   ob_modifier);
7027       else
7028         cp_error ("`%D' can only be specified for objects and functions",
7029                   ob_modifier);
7030     }
7031
7032   return t;
7033 }
7034
7035 /* Called when a declaration is seen that contains no names to declare.
7036    If its type is a reference to a structure, union or enum inherited
7037    from a containing scope, shadow that tag name for the current scope
7038    with a forward reference.
7039    If its type defines a new named structure or union
7040    or defines an enum, it is valid but we need not do anything here.
7041    Otherwise, it is an error.
7042
7043    C++: may have to grok the declspecs to learn about static,
7044    complain for anonymous unions.  */
7045
7046 void
7047 shadow_tag (declspecs)
7048      tree declspecs;
7049 {
7050   tree t = check_tag_decl (declspecs);
7051
7052   if (t)
7053     maybe_process_partial_specialization (t);
7054
7055   /* This is where the variables in an anonymous union are
7056      declared.  An anonymous union declaration looks like:
7057      union { ... } ;
7058      because there is no declarator after the union, the parser
7059      sends that declaration here.  */
7060   if (t && ANON_AGGR_TYPE_P (t))
7061     {
7062       fixup_anonymous_aggr (t);
7063
7064       if (TYPE_FIELDS (t))
7065         {
7066           tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
7067                                       NULL_TREE);
7068           finish_anon_union (decl);
7069         }
7070     }
7071 }
7072 \f
7073 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
7074
7075 tree
7076 groktypename (typename)
7077      tree typename;
7078 {
7079   if (TREE_CODE (typename) != TREE_LIST)
7080     return typename;
7081   return grokdeclarator (TREE_VALUE (typename),
7082                          TREE_PURPOSE (typename),
7083                          TYPENAME, 0, NULL_TREE);
7084 }
7085
7086 /* Decode a declarator in an ordinary declaration or data definition.
7087    This is called as soon as the type information and variable name
7088    have been parsed, before parsing the initializer if any.
7089    Here we create the ..._DECL node, fill in its type,
7090    and put it on the list of decls for the current context.
7091    The ..._DECL node is returned as the value.
7092
7093    Exception: for arrays where the length is not specified,
7094    the type is left null, to be filled in by `cp_finish_decl'.
7095
7096    Function definitions do not come here; they go to start_function
7097    instead.  However, external and forward declarations of functions
7098    do go through here.  Structure field declarations are done by
7099    grokfield and not through here.  */
7100
7101 tree
7102 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
7103      tree declarator, declspecs;
7104      int initialized;
7105      tree attributes, prefix_attributes;
7106 {
7107   register tree decl;
7108   register tree type, tem;
7109   tree context;
7110   extern int have_extern_spec;
7111   extern int used_extern_spec;
7112   tree attrlist;
7113
7114 #if 0
7115   /* See code below that used this.  */
7116   int init_written = initialized;
7117 #endif
7118
7119   /* This should only be done once on the top most decl.  */
7120   if (have_extern_spec && !used_extern_spec)
7121     {
7122       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"),
7123                                   declspecs);
7124       used_extern_spec = 1;
7125     }
7126
7127   if (attributes || prefix_attributes)
7128     attrlist = build_tree_list (attributes, prefix_attributes);
7129   else
7130     attrlist = NULL_TREE;
7131
7132   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
7133                          attrlist);
7134
7135   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
7136     return NULL_TREE;
7137
7138   type = TREE_TYPE (decl);
7139
7140   if (type == error_mark_node)
7141     return NULL_TREE;
7142
7143   context = DECL_CONTEXT (decl);
7144
7145   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
7146       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
7147     {
7148       /* When parsing the initializer, lookup should use the object's
7149          namespace. */
7150       push_decl_namespace (context);
7151     }
7152
7153   /* We are only interested in class contexts, later. */
7154   if (context && TREE_CODE (context) == NAMESPACE_DECL)
7155     context = NULL_TREE;
7156
7157   if (initialized)
7158     /* Is it valid for this decl to have an initializer at all?
7159        If not, set INITIALIZED to zero, which will indirectly
7160        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7161     switch (TREE_CODE (decl))
7162       {
7163       case TYPE_DECL:
7164         /* typedef foo = bar  means give foo the same type as bar.
7165            We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
7166            Any other case of an initialization in a TYPE_DECL is an error.  */
7167         if (pedantic || list_length (declspecs) > 1)
7168           {
7169             cp_error ("typedef `%D' is initialized", decl);
7170             initialized = 0;
7171           }
7172         break;
7173
7174       case FUNCTION_DECL:
7175         cp_error ("function `%#D' is initialized like a variable", decl);
7176         initialized = 0;
7177         break;
7178
7179       default:
7180         break;
7181       }
7182
7183   if (initialized)
7184     {
7185       if (! toplevel_bindings_p ()
7186           && DECL_EXTERNAL (decl))
7187         cp_warning ("declaration of `%#D' has `extern' and is initialized",
7188                     decl);
7189       DECL_EXTERNAL (decl) = 0;
7190       if (toplevel_bindings_p ())
7191         TREE_STATIC (decl) = 1;
7192
7193       /* Tell `pushdecl' this is an initialized decl
7194          even though we don't yet have the initializer expression.
7195          Also tell `cp_finish_decl' it may store the real initializer.  */
7196       DECL_INITIAL (decl) = error_mark_node;
7197     }
7198
7199 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
7200   SET_DEFAULT_DECL_ATTRIBUTES (decl, attributes);
7201 #endif
7202
7203   /* Set attributes here so if duplicate decl, will have proper attributes.  */
7204   cplus_decl_attributes (decl, attributes, prefix_attributes);
7205
7206   if (context && COMPLETE_TYPE_P (complete_type (context)))
7207     {
7208       push_nested_class (context, 2);
7209
7210       if (TREE_CODE (decl) == VAR_DECL)
7211         {
7212           tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
7213           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
7214             cp_error ("`%#D' is not a static member of `%#T'", decl, context);
7215           else
7216             {
7217               if (DECL_CONTEXT (field) != context)
7218                 {
7219                   cp_pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
7220                               DECL_CONTEXT (field), DECL_NAME (decl),
7221                               context, DECL_NAME (decl));
7222                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
7223                 }
7224               /* Static data member are tricky; an in-class initialization
7225                  still doesn't provide a definition, so the in-class
7226                  declaration will have DECL_EXTERNAL set, but will have an
7227                  initialization.  Thus, duplicate_decls won't warn
7228                  about this situation, and so we check here.  */
7229               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
7230                 cp_error ("duplicate initialization of %D", decl);
7231               if (duplicate_decls (decl, field))
7232                 decl = field;
7233             }
7234         }
7235       else
7236         {
7237           tree field = check_classfn (context, decl);
7238           if (field && duplicate_decls (decl, field))
7239             decl = field;
7240         }
7241
7242       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
7243       DECL_IN_AGGR_P (decl) = 0;
7244       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
7245           || CLASSTYPE_TEMPLATE_INSTANTIATION (context))
7246         {
7247           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
7248           /* [temp.expl.spec] An explicit specialization of a static data
7249              member of a template is a definition if the declaration
7250              includes an initializer; otherwise, it is a declaration.
7251
7252              We check for processing_specialization so this only applies
7253              to the new specialization syntax.  */
7254           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
7255             DECL_EXTERNAL (decl) = 1;
7256         }
7257
7258       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
7259         cp_pedwarn ("declaration of `%#D' outside of class is not definition",
7260                     decl);
7261     }
7262
7263   /* Enter this declaration into the symbol table.  */
7264   tem = maybe_push_decl (decl);
7265
7266   if (processing_template_decl)
7267     tem = push_template_decl (tem);
7268
7269 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7270   /* Tell the back-end to use or not use .common as appropriate.  If we say
7271      -fconserve-space, we want this to save .data space, at the expense of
7272      wrong semantics.  If we say -fno-conserve-space, we want this to
7273      produce errors about redefs; to do this we force variables into the
7274      data segment.  */
7275   DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
7276 #endif
7277
7278   if (! processing_template_decl)
7279     start_decl_1 (tem);
7280
7281   return tem;
7282 }
7283
7284 void
7285 start_decl_1 (decl)
7286      tree decl;
7287 {
7288   tree type = TREE_TYPE (decl);
7289   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
7290
7291   if (type == error_mark_node)
7292     return;
7293
7294   /* If this type of object needs a cleanup, but we're not allowed to
7295      add any more objects with cleanups to the current scope, create a
7296      new binding level.  */
7297   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
7298       && current_binding_level->more_cleanups_ok == 0)
7299     {
7300       keep_next_level (2);
7301       pushlevel (1);
7302       clear_last_expr ();
7303       add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
7304     }
7305
7306   if (initialized)
7307     /* Is it valid for this decl to have an initializer at all?
7308        If not, set INITIALIZED to zero, which will indirectly
7309        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7310     {
7311       /* Don't allow initializations for incomplete types except for
7312          arrays which might be completed by the initialization.  */
7313       if (COMPLETE_TYPE_P (complete_type (type)))
7314         ;                       /* A complete type is ok.  */
7315       else if (TREE_CODE (type) != ARRAY_TYPE)
7316         {
7317           cp_error ("variable `%#D' has initializer but incomplete type",
7318                     decl);
7319           initialized = 0;
7320           type = TREE_TYPE (decl) = error_mark_node;
7321         }
7322       else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7323         {
7324           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
7325             cp_error ("elements of array `%#D' have incomplete type", decl);
7326           /* else we already gave an error in start_decl.  */
7327           initialized = 0;
7328         }
7329     }
7330
7331   if (!initialized
7332       && TREE_CODE (decl) != TYPE_DECL
7333       && TREE_CODE (decl) != TEMPLATE_DECL
7334       && type != error_mark_node
7335       && IS_AGGR_TYPE (type)
7336       && ! DECL_EXTERNAL (decl))
7337     {
7338       if ((! processing_template_decl || ! uses_template_parms (type))
7339           && !COMPLETE_TYPE_P (complete_type (type)))
7340         {
7341           cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
7342                  decl);
7343           /* Change the type so that assemble_variable will give
7344              DECL an rtl we can live with: (mem (const_int 0)).  */
7345           type = TREE_TYPE (decl) = error_mark_node;
7346         }
7347       else
7348         {
7349           /* If any base type in the hierarchy of TYPE needs a constructor,
7350              then we set initialized to 1.  This way any nodes which are
7351              created for the purposes of initializing this aggregate
7352              will live as long as it does.  This is necessary for global
7353              aggregates which do not have their initializers processed until
7354              the end of the file.  */
7355           initialized = TYPE_NEEDS_CONSTRUCTING (type);
7356         }
7357     }
7358
7359   if (! initialized)
7360     DECL_INITIAL (decl) = NULL_TREE;
7361 }
7362
7363 /* Handle initialization of references.
7364    These three arguments are from `cp_finish_decl', and have the
7365    same meaning here that they do there.
7366
7367    Quotes on semantics can be found in ARM 8.4.3.  */
7368
7369 static void
7370 grok_reference_init (decl, type, init)
7371      tree decl, type, init;
7372 {
7373   tree tmp;
7374
7375   if (init == NULL_TREE)
7376     {
7377       if ((DECL_LANG_SPECIFIC (decl) == 0
7378            || DECL_IN_AGGR_P (decl) == 0)
7379           && ! DECL_THIS_EXTERN (decl))
7380         cp_error ("`%D' declared as reference but not initialized", decl);
7381       return;
7382     }
7383
7384   if (init == error_mark_node)
7385     return;
7386
7387   if (TREE_CODE (init) == CONSTRUCTOR)
7388     {
7389       cp_error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
7390       return;
7391     }
7392
7393   if (TREE_CODE (init) == TREE_LIST)
7394     init = build_compound_expr (init);
7395
7396   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
7397     init = convert_from_reference (init);
7398
7399   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
7400       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
7401     {
7402       /* Note: default conversion is only called in very special cases.  */
7403       init = default_conversion (init);
7404     }
7405
7406   /* Convert INIT to the reference type TYPE.  This may involve the
7407      creation of a temporary, whose lifetime must be the same as that
7408      of the reference.  If so, a DECL_STMT for the temporary will be
7409      added just after the DECL_STMT for DECL.  That's why we don't set
7410      DECL_INITIAL for local references (instead assigning to them
7411      explicitly); we need to allow the temporary to be initialized
7412      first.  */
7413   tmp = convert_to_reference
7414     (type, init, CONV_IMPLICIT,
7415      LOOKUP_ONLYCONVERTING|LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND,
7416      decl);
7417
7418   if (tmp == error_mark_node)
7419     return;
7420   else if (tmp != NULL_TREE)
7421     {
7422       init = tmp;
7423       tmp = save_expr (tmp);
7424       if (building_stmt_tree ())
7425         {
7426           /* Initialize the declaration.  */
7427           tmp = build (INIT_EXPR, TREE_TYPE (decl), decl, tmp);
7428           finish_expr_stmt (tmp);
7429         }
7430       else
7431         DECL_INITIAL (decl) = tmp;
7432     }
7433   else
7434     {
7435       cp_error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
7436       return;
7437     }
7438
7439   if (TREE_STATIC (decl) && ! TREE_CONSTANT (DECL_INITIAL (decl)))
7440     {
7441       expand_static_init (decl, DECL_INITIAL (decl));
7442       DECL_INITIAL (decl) = NULL_TREE;
7443     }
7444   return;
7445 }
7446
7447 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7448    mucking with forces it does not comprehend (i.e. initialization with a
7449    constructor).  If we are at global scope and won't go into COMMON, fill
7450    it in with a dummy CONSTRUCTOR to force the variable into .data;
7451    otherwise we can use error_mark_node.  */
7452
7453 static tree
7454 obscure_complex_init (decl, init)
7455      tree decl, init;
7456 {
7457   if (! flag_no_inline && TREE_STATIC (decl))
7458     {
7459       if (extract_init (decl, init))
7460         return NULL_TREE;
7461     }
7462
7463 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7464   if (toplevel_bindings_p () && ! DECL_COMMON (decl))
7465     DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
7466                                  NULL_TREE);
7467   else
7468 #endif
7469     DECL_INITIAL (decl) = error_mark_node;
7470
7471   return init;
7472 }
7473
7474 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7475    array until we finish parsing the initializer.  If that's the
7476    situation we're in, update DECL accordingly.  */
7477
7478 static void
7479 maybe_deduce_size_from_array_init (decl, init)
7480      tree decl;
7481      tree init;
7482 {
7483   tree type = TREE_TYPE (decl);
7484
7485   if (TREE_CODE (type) == ARRAY_TYPE
7486       && TYPE_DOMAIN (type) == NULL_TREE
7487       && TREE_CODE (decl) != TYPE_DECL)
7488     {
7489       int do_default
7490         = (TREE_STATIC (decl)
7491            /* Even if pedantic, an external linkage array
7492               may have incomplete type at first.  */
7493            ? pedantic && ! DECL_EXTERNAL (decl)
7494            : !DECL_EXTERNAL (decl));
7495       tree initializer = init ? init : DECL_INITIAL (decl);
7496       int failure = complete_array_type (type, initializer, do_default);
7497
7498       if (failure == 1)
7499         cp_error ("initializer fails to determine size of `%D'", decl);
7500
7501       if (failure == 2)
7502         {
7503           if (do_default)
7504             cp_error ("array size missing in `%D'", decl);
7505           /* If a `static' var's size isn't known, make it extern as
7506              well as static, so it does not get allocated.  If it's not
7507              `static', then don't mark it extern; finish_incomplete_decl
7508              will give it a default size and it will get allocated.  */
7509           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7510             DECL_EXTERNAL (decl) = 1;
7511         }
7512
7513       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7514           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7515                               integer_zero_node))
7516         cp_error ("zero-size array `%D'", decl);
7517
7518       layout_decl (decl, 0);
7519     }
7520 }
7521
7522 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7523    any appropriate error messages regarding the layout.  */
7524
7525 static void
7526 layout_var_decl (decl)
7527      tree decl;
7528 {
7529   tree type = TREE_TYPE (decl);
7530 #if 0
7531   tree ttype = target_type (type);
7532 #endif
7533
7534   /* If we haven't already layed out this declaration, do so now.
7535      Note that we must not call complete type for an external object
7536      because it's type might involve templates that we are not
7537      supposed to isntantiate yet.  (And it's perfectly legal to say
7538      `extern X x' for some incomplete type `X'.)  */
7539   if (!DECL_EXTERNAL (decl))
7540     complete_type (type);
7541   if (!DECL_SIZE (decl) && COMPLETE_TYPE_P (type))
7542     layout_decl (decl, 0);
7543
7544   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7545     {
7546       /* An automatic variable with an incomplete type: that is an error.
7547          Don't talk about array types here, since we took care of that
7548          message in grokdeclarator.  */
7549       cp_error ("storage size of `%D' isn't known", decl);
7550       TREE_TYPE (decl) = error_mark_node;
7551     }
7552 #if 0
7553   /* Keep this code around in case we later want to control debug info
7554      based on whether a type is "used".  (jason 1999-11-11) */
7555
7556   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7557     /* Let debugger know it should output info for this type.  */
7558     note_debug_info_needed (ttype);
7559
7560   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7561     note_debug_info_needed (DECL_CONTEXT (decl));
7562 #endif
7563
7564   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7565       && DECL_SIZE (decl) != NULL_TREE
7566       && ! TREE_CONSTANT (DECL_SIZE (decl)))
7567     {
7568       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7569         constant_expression_warning (DECL_SIZE (decl));
7570       else
7571         cp_error ("storage size of `%D' isn't constant", decl);
7572     }
7573 }
7574
7575 /* If a local static variable is declared in an inline function, or if
7576    we have a weak definition, we must endeavor to create only one
7577    instance of the variable at link-time.  */
7578
7579 static void
7580 maybe_commonize_var (decl)
7581      tree decl;
7582 {
7583   /* Static data in a function with comdat linkage also has comdat
7584      linkage.  */
7585   if (TREE_STATIC (decl)
7586       /* Don't mess with __FUNCTION__.  */
7587       && ! DECL_ARTIFICIAL (decl)
7588       && current_function_decl
7589       && DECL_CONTEXT (decl) == current_function_decl
7590       && (DECL_THIS_INLINE (current_function_decl)
7591           || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7592       && TREE_PUBLIC (current_function_decl))
7593     {
7594       /* Rather than try to get this right with inlining, we suppress
7595          inlining of such functions.  */
7596       current_function_cannot_inline
7597         = "function with static variable cannot be inline";
7598
7599       /* If flag_weak, we don't need to mess with this, as we can just
7600          make the function weak, and let it refer to its unique local
7601          copy.  This works because we don't allow the function to be
7602          inlined.  */
7603       if (! flag_weak)
7604         {
7605           if (DECL_INTERFACE_KNOWN (current_function_decl))
7606             {
7607               TREE_PUBLIC (decl) = 1;
7608               DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7609             }
7610           else if (DECL_INITIAL (decl) == NULL_TREE
7611                    || DECL_INITIAL (decl) == error_mark_node)
7612             {
7613               TREE_PUBLIC (decl) = 1;
7614               DECL_COMMON (decl) = 1;
7615             }
7616           /* else we lose. We can only do this if we can use common,
7617              which we can't if it has been initialized.  */
7618
7619           if (TREE_PUBLIC (decl))
7620             DECL_ASSEMBLER_NAME (decl)
7621               = build_static_name (current_function_decl, DECL_NAME (decl));
7622           else
7623             {
7624               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7625               cp_warning_at ("  you can work around this by removing the initializer", decl);
7626             }
7627         }
7628     }
7629   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7630     /* Set it up again; we might have set DECL_INITIAL since the last
7631        time.  */
7632     comdat_linkage (decl);
7633 }
7634
7635 /* Issue an error message if DECL is an uninitialized const variable.  */
7636
7637 static void
7638 check_for_uninitialized_const_var (decl)
7639      tree decl;
7640 {
7641   tree type = TREE_TYPE (decl);
7642
7643   /* ``Unless explicitly declared extern, a const object does not have
7644      external linkage and must be initialized. ($8.4; $12.1)'' ARM
7645      7.1.6 */
7646   if (TREE_CODE (decl) == VAR_DECL
7647       && TREE_CODE (type) != REFERENCE_TYPE
7648       && CP_TYPE_CONST_P (type)
7649       && !TYPE_NEEDS_CONSTRUCTING (type)
7650       && !DECL_INITIAL (decl))
7651     cp_error ("uninitialized const `%D'", decl);
7652 }
7653
7654 /* Verify INIT (the initializer for DECL), and record the
7655    initialization in DECL_INITIAL, if appropriate.  Returns a new
7656    value for INIT.  */
7657
7658 static tree
7659 check_initializer (decl, init)
7660      tree decl;
7661      tree init;
7662 {
7663   tree type;
7664
7665   if (TREE_CODE (decl) == FIELD_DECL)
7666     return init;
7667
7668   type = TREE_TYPE (decl);
7669
7670   /* If `start_decl' didn't like having an initialization, ignore it now.  */
7671   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7672     init = NULL_TREE;
7673
7674   /* Check the initializer.  */
7675   if (init)
7676     {
7677       /* Things that are going to be initialized need to have complete
7678          type.  */
7679       TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7680
7681       if (type == error_mark_node)
7682         /* We will have already complained.  */
7683         init = NULL_TREE;
7684       else if (COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
7685         {
7686           cp_error ("variable-sized object `%D' may not be initialized", decl);
7687           init = NULL_TREE;
7688         }
7689       else if (TREE_CODE (type) == ARRAY_TYPE
7690                && !COMPLETE_TYPE_P (TREE_TYPE (type)))
7691         {
7692           cp_error ("elements of array `%#D' have incomplete type", decl);
7693           init = NULL_TREE;
7694         }
7695       else if (!COMPLETE_TYPE_P (type))
7696         {
7697           cp_error ("`%D' has incomplete type", decl);
7698           TREE_TYPE (decl) = error_mark_node;
7699           init = NULL_TREE;
7700         }
7701     }
7702
7703   if (TREE_CODE (decl) == CONST_DECL)
7704     {
7705       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7706
7707       DECL_INITIAL (decl) = init;
7708
7709       /* This will keep us from needing to worry about our obstacks.  */
7710       my_friendly_assert (init != NULL_TREE, 149);
7711       init = NULL_TREE;
7712     }
7713   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7714     {
7715       if (TREE_STATIC (decl))
7716         make_decl_rtl (decl, NULL_PTR, toplevel_bindings_p ());
7717       grok_reference_init (decl, type, init);
7718       init = NULL_TREE;
7719     }
7720   else if (init)
7721     {
7722       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7723         {
7724           if (TREE_CODE (type) == ARRAY_TYPE)
7725             init = digest_init (type, init, (tree *) 0);
7726           else if (TREE_CODE (init) == CONSTRUCTOR
7727                    && TREE_HAS_CONSTRUCTOR (init))
7728             {
7729               if (TYPE_NON_AGGREGATE_CLASS (type))
7730                 {
7731                   cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7732                             decl);
7733                   init = error_mark_node;
7734                 }
7735               else
7736                 goto dont_use_constructor;
7737             }
7738         }
7739       else
7740         {
7741         dont_use_constructor:
7742           if (TREE_CODE (init) != TREE_VEC)
7743             init = store_init_value (decl, init);
7744         }
7745
7746       if (init)
7747         /* We must hide the initializer so that expand_decl
7748            won't try to do something it does not understand.  */
7749         init = obscure_complex_init (decl, init);
7750     }
7751   else if (DECL_EXTERNAL (decl))
7752     ;
7753   else if (TYPE_P (type)
7754            && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
7755     {
7756       tree core_type = strip_array_types (type);
7757
7758       if (! TYPE_NEEDS_CONSTRUCTING (core_type))
7759         {
7760           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
7761             cp_error ("structure `%D' with uninitialized const members", decl);
7762           if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
7763             cp_error ("structure `%D' with uninitialized reference members",
7764                       decl);
7765         }
7766
7767       check_for_uninitialized_const_var (decl);
7768
7769       if (COMPLETE_TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
7770         init = obscure_complex_init (decl, NULL_TREE);
7771
7772     }
7773   else
7774     check_for_uninitialized_const_var (decl);
7775
7776   return init;
7777 }
7778
7779 /* If DECL is not a local variable, give it RTL.  */
7780
7781 static void
7782 make_rtl_for_nonlocal_decl (decl, init, asmspec)
7783      tree decl;
7784      tree init;
7785      const char *asmspec;
7786 {
7787   int toplev = toplevel_bindings_p ();
7788   int defer_p;
7789
7790   /* Handle non-variables up front.  */
7791   if (TREE_CODE (decl) != VAR_DECL)
7792     {
7793       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7794       return;
7795     }
7796
7797   /* If we see a class member here, it should be a static data
7798      member.  */
7799   if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
7800     {
7801       my_friendly_assert (TREE_STATIC (decl), 19990828);
7802       /* An in-class declaration of a static data member should be
7803          external; it is only a declaration, and not a definition.  */
7804       if (init == NULL_TREE)
7805         my_friendly_assert (DECL_EXTERNAL (decl), 20000723);
7806     }
7807
7808   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
7809   if (asmspec)
7810     DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
7811
7812   /* We don't create any RTL for local variables.  */
7813   if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
7814     return;
7815
7816   /* We defer emission of local statics until the corresponding
7817      DECL_STMT is expanded.  */
7818   defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
7819
7820   /* We try to defer namespace-scope static constants so that they are
7821      not emitted into the object file unncessarily.  */
7822   if (!DECL_VIRTUAL_P (decl)
7823       && TREE_READONLY (decl)
7824       && DECL_INITIAL (decl) != NULL_TREE
7825       && DECL_INITIAL (decl) != error_mark_node
7826       && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
7827       && toplev
7828       && !TREE_PUBLIC (decl))
7829     {
7830       /* Fool with the linkage according to #pragma interface.  */
7831       if (!interface_unknown)
7832         {
7833           TREE_PUBLIC (decl) = 1;
7834           DECL_EXTERNAL (decl) = interface_only;
7835         }
7836
7837       defer_p = 1;
7838     }
7839
7840   /* If we're deferring the variable, just make RTL.  Do not actually
7841      emit the variable.  */
7842   if (defer_p)
7843     make_decl_rtl (decl, asmspec, toplev);
7844   /* If we're not deferring, go ahead and assemble the variable.  */
7845   else
7846     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7847 }
7848
7849 /* The old ARM scoping rules injected variables declared in the
7850    initialization statement of a for-statement into the surrounding
7851    scope.  We support this usage, in order to be backward-compatible.
7852    DECL is a just-declared VAR_DECL; if necessary inject its
7853    declaration into the surrounding scope.  */
7854
7855 void
7856 maybe_inject_for_scope_var (decl)
7857      tree decl;
7858 {
7859   if (!DECL_NAME (decl))
7860     return;
7861
7862   if (current_binding_level->is_for_scope)
7863     {
7864       struct binding_level *outer
7865         = current_binding_level->level_chain;
7866
7867       /* Check to see if the same name is already bound at the outer
7868          level, either because it was directly declared, or because a
7869          dead for-decl got preserved.  In either case, the code would
7870          not have been valid under the ARM scope rules, so clear
7871          is_for_scope for the current_binding_level.
7872
7873          Otherwise, we need to preserve the temp slot for decl to last
7874          into the outer binding level.  */
7875
7876       tree outer_binding
7877         = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
7878
7879       if (outer_binding && BINDING_LEVEL (outer_binding) == outer
7880           && (TREE_CODE (BINDING_VALUE (outer_binding))
7881               == VAR_DECL)
7882           && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
7883         {
7884           BINDING_VALUE (outer_binding)
7885             = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
7886           current_binding_level->is_for_scope = 0;
7887         }
7888       else if (DECL_IN_MEMORY_P (decl))
7889         preserve_temp_slots (DECL_RTL (decl));
7890     }
7891 }
7892
7893 /* Generate code to initialize DECL (a local variable).  */
7894
7895 void
7896 initialize_local_var (decl, init, flags)
7897      tree decl;
7898      tree init;
7899      int flags;
7900 {
7901   tree type = TREE_TYPE (decl);
7902
7903   /* If the type is bogus, don't bother initializing the variable.  */
7904   if (type == error_mark_node)
7905     return;
7906
7907   if (DECL_SIZE (decl) == NULL_TREE && !TREE_STATIC (decl))
7908     {
7909       /* If we used it already as memory, it must stay in memory.  */
7910       DECL_INITIAL (decl) = NULL_TREE;
7911       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
7912     }
7913
7914   /* Local statics are handled differently from ordinary automatic
7915      variables.  */
7916   if (TREE_STATIC (decl))
7917     {
7918       if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7919           || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7920         expand_static_init (decl, init);
7921       return;
7922     }
7923
7924   if (DECL_SIZE (decl) && type != error_mark_node)
7925     {
7926       int already_used;
7927
7928       /* Compute and store the initial value.  */
7929       already_used = TREE_USED (decl) || TREE_USED (type);
7930
7931       if (init || TYPE_NEEDS_CONSTRUCTING (type))
7932         {
7933           int saved_stmts_are_full_exprs_p;
7934
7935           emit_line_note (DECL_SOURCE_FILE (decl),
7936                           DECL_SOURCE_LINE (decl));
7937           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
7938           current_stmt_tree->stmts_are_full_exprs_p = 1;
7939           if (building_stmt_tree ())
7940             finish_expr_stmt (build_aggr_init (decl, init, flags));
7941           else
7942             genrtl_expr_stmt (build_aggr_init (decl, init, flags));
7943           current_stmt_tree->stmts_are_full_exprs_p = saved_stmts_are_full_exprs_p;
7944         }
7945
7946       /* Set this to 0 so we can tell whether an aggregate which was
7947          initialized was ever used.  Don't do this if it has a
7948          destructor, so we don't complain about the 'resource
7949          allocation is initialization' idiom.  Now set
7950          attribute((unused)) on types so decls of that type will be
7951          marked used. (see TREE_USED, above.)  */
7952       if (TYPE_NEEDS_CONSTRUCTING (type)
7953           && ! already_used
7954           && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
7955           && DECL_NAME (decl))
7956         TREE_USED (decl) = 0;
7957       else if (already_used)
7958         TREE_USED (decl) = 1;
7959     }
7960 }
7961
7962 /* Generate code to destroy DECL (a local variable).  */
7963
7964 static void
7965 destroy_local_var (decl)
7966      tree decl;
7967 {
7968   tree type = TREE_TYPE (decl);
7969   tree cleanup;
7970
7971   /* Only variables get cleaned up.  */
7972   if (TREE_CODE (decl) != VAR_DECL)
7973     return;
7974
7975   /* And only things with destructors need cleaning up.  */
7976   if (type == error_mark_node
7977       || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
7978     return;
7979
7980   if (TREE_CODE (decl) == VAR_DECL &&
7981       (DECL_EXTERNAL (decl) || TREE_STATIC (decl)))
7982     /* We don't clean up things that aren't defined in this
7983        translation unit, or that need a static cleanup.  The latter
7984        are handled by finish_file.  */
7985     return;
7986
7987   /* Compute the cleanup.  */
7988   cleanup = maybe_build_cleanup (decl);
7989
7990   /* Record the cleanup required for this declaration.  */
7991   if (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node
7992       && cleanup)
7993     finish_decl_cleanup (decl, cleanup);
7994 }
7995
7996 /* Finish processing of a declaration;
7997    install its line number and initial value.
7998    If the length of an array type is not known before,
7999    it must be determined now, from the initial value, or it is an error.
8000
8001    INIT holds the value of an initializer that should be allowed to escape
8002    the normal rules.
8003
8004    FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
8005    if the (init) syntax was used.  */
8006
8007 void
8008 cp_finish_decl (decl, init, asmspec_tree, flags)
8009      tree decl, init;
8010      tree asmspec_tree;
8011      int flags;
8012 {
8013   register tree type;
8014   tree ttype = NULL_TREE;
8015   const char *asmspec = NULL;
8016   int was_readonly = 0;
8017
8018   if (! decl)
8019     {
8020       if (init)
8021         error ("assignment (not initialization) in declaration");
8022       return;
8023     }
8024
8025   /* If a name was specified, get the string.  */
8026   if (asmspec_tree)
8027       asmspec = TREE_STRING_POINTER (asmspec_tree);
8028
8029   if (init && TREE_CODE (init) == NAMESPACE_DECL)
8030     {
8031       cp_error ("cannot initialize `%D' to namespace `%D'",
8032                 decl, init);
8033       init = NULL_TREE;
8034     }
8035
8036   if (current_class_type
8037       && CP_DECL_CONTEXT (decl) == current_class_type
8038       && TYPE_BEING_DEFINED (current_class_type)
8039       && (DECL_INITIAL (decl) || init))
8040     DECL_DEFINED_IN_CLASS_P (decl) = 1;
8041
8042   if (TREE_CODE (decl) == VAR_DECL
8043       && DECL_CONTEXT (decl)
8044       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
8045       && DECL_CONTEXT (decl) != current_namespace
8046       && init)
8047     {
8048       /* Leave the namespace of the object. */
8049       pop_decl_namespace ();
8050     }
8051
8052   type = TREE_TYPE (decl);
8053
8054   if (type == error_mark_node)
8055     return;
8056
8057   /* Add this declaration to the statement-tree.  */
8058   if (building_stmt_tree () && at_function_scope_p ())
8059     add_decl_stmt (decl);
8060
8061   if (TYPE_HAS_MUTABLE_P (type))
8062     TREE_READONLY (decl) = 0;
8063
8064   if (processing_template_decl)
8065     {
8066       if (init && DECL_INITIAL (decl))
8067         DECL_INITIAL (decl) = init;
8068       goto finish_end0;
8069     }
8070
8071   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
8072   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
8073
8074   /* Take care of TYPE_DECLs up front.  */
8075   if (TREE_CODE (decl) == TYPE_DECL)
8076     {
8077       if (init && DECL_INITIAL (decl))
8078         {
8079           /* typedef foo = bar; store the type of bar as the type of foo.  */
8080           TREE_TYPE (decl) = type = TREE_TYPE (init);
8081           DECL_INITIAL (decl) = init = NULL_TREE;
8082         }
8083       if (type != error_mark_node
8084           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
8085         {
8086           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
8087             cp_warning ("shadowing previous type declaration of `%#D'", decl);
8088           set_identifier_type_value (DECL_NAME (decl), type);
8089           CLASSTYPE_GOT_SEMICOLON (type) = 1;
8090         }
8091       GNU_xref_decl (current_function_decl, decl);
8092
8093       /* If we have installed this as the canonical typedef for this
8094          type, and that type has not been defined yet, delay emitting
8095          the debug information for it, as we will emit it later.  */
8096       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
8097           && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
8098         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
8099
8100       rest_of_decl_compilation (decl, NULL_PTR,
8101                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
8102       goto finish_end;
8103     }
8104
8105   if (TREE_CODE (decl) != FUNCTION_DECL)
8106     ttype = target_type (type);
8107
8108   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
8109       && TYPE_NEEDS_CONSTRUCTING (type))
8110     {
8111       /* Currently, GNU C++ puts constants in text space, making them
8112          impossible to initialize.  In the future, one would hope for
8113          an operating system which understood the difference between
8114          initialization and the running of a program.  */
8115       was_readonly = 1;
8116       TREE_READONLY (decl) = 0;
8117     }
8118
8119   if (TREE_CODE (decl) == FIELD_DECL && asmspec)
8120     {
8121       /* This must override the asm specifier which was placed by
8122          grokclassfn.  Lay this out fresh.  */
8123       DECL_RTL (TREE_TYPE (decl)) = NULL_RTX;
8124       DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
8125       make_decl_rtl (decl, asmspec, 0);
8126     }
8127
8128   /* Deduce size of array from initialization, if not already known.  */
8129   maybe_deduce_size_from_array_init (decl, init);
8130   init = check_initializer (decl, init);
8131
8132   GNU_xref_decl (current_function_decl, decl);
8133
8134   if (TREE_CODE (decl) == VAR_DECL)
8135     layout_var_decl (decl);
8136
8137   /* Output the assembler code and/or RTL code for variables and functions,
8138      unless the type is an undefined structure or union.
8139      If not, it will get done when the type is completed.  */
8140   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
8141       || TREE_CODE (decl) == RESULT_DECL)
8142     {
8143       if (TREE_CODE (decl) == VAR_DECL)
8144         maybe_commonize_var (decl);
8145
8146       make_rtl_for_nonlocal_decl (decl, init, asmspec);
8147
8148       if (TREE_CODE (type) == FUNCTION_TYPE
8149           || TREE_CODE (type) == METHOD_TYPE)
8150         abstract_virtuals_error (decl,
8151                                  strip_array_types (TREE_TYPE (type)));
8152       else
8153         abstract_virtuals_error (decl, strip_array_types (type));
8154
8155       if (TREE_CODE (decl) == FUNCTION_DECL)
8156         ;
8157       else if (DECL_EXTERNAL (decl)
8158                && ! (DECL_LANG_SPECIFIC (decl)
8159                      && DECL_NOT_REALLY_EXTERN (decl)))
8160         {
8161           if (init)
8162             DECL_INITIAL (decl) = init;
8163         }
8164       else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
8165         {
8166           /* This is a local declaration.  */
8167           if (doing_semantic_analysis_p ())
8168             maybe_inject_for_scope_var (decl);
8169           /* Initialize the local variable.  But, if we're building a
8170              statement-tree, we'll do the initialization when we
8171              expand the tree.  */
8172           if (processing_template_decl)
8173             {
8174               if (init || DECL_INITIAL (decl) == error_mark_node)
8175                 DECL_INITIAL (decl) = init;
8176             }
8177           else
8178             {
8179               /* If we're not building RTL, then we need to do so
8180                  now.  */
8181               if (!building_stmt_tree ())
8182                 emit_local_var (decl);
8183               /* Initialize the variable.  */
8184               initialize_local_var (decl, init, flags);
8185               /* Clean up the variable.  */
8186               destroy_local_var (decl);
8187             }
8188         }
8189       else if (TREE_STATIC (decl) && type != error_mark_node)
8190         {
8191           /* Cleanups for static variables are handled by `finish_file'.  */
8192           if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
8193               || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8194             expand_static_init (decl, init);
8195         }
8196     finish_end0:
8197
8198       /* Undo call to `pushclass' that was done in `start_decl'
8199          due to initialization of qualified member variable.
8200          I.e., Foo::x = 10;  */
8201       {
8202         tree context = CP_DECL_CONTEXT (decl);
8203         if (context
8204             && TYPE_P (context)
8205             && (TREE_CODE (decl) == VAR_DECL
8206                 /* We also have a pushclass done that we need to undo here
8207                    if we're at top level and declare a method.  */
8208                 || TREE_CODE (decl) == FUNCTION_DECL)
8209             /* If size hasn't been set, we're still defining it,
8210                and therefore inside the class body; don't pop
8211                the binding level..  */
8212             && COMPLETE_TYPE_P (context)
8213             && context == current_class_type)
8214           pop_nested_class ();
8215       }
8216     }
8217
8218  finish_end:
8219
8220   if (was_readonly)
8221     TREE_READONLY (decl) = 1;
8222 }
8223
8224 /* This is here for a midend callback from c-common.c */
8225
8226 void
8227 finish_decl (decl, init, asmspec_tree)
8228      tree decl, init;
8229      tree asmspec_tree;
8230 {
8231   cp_finish_decl (decl, init, asmspec_tree, 0);
8232 }
8233
8234 /* Returns a declaration for a VAR_DECL as if:
8235
8236      extern "C" TYPE NAME;
8237
8238    had been seen.  Used to create compiler-generated global
8239    variables.  */
8240
8241 tree
8242 declare_global_var (name, type)
8243      tree name;
8244      tree type;
8245 {
8246   tree decl;
8247
8248   push_to_top_level ();
8249   decl = build_decl (VAR_DECL, name, type);
8250   TREE_PUBLIC (decl) = 1;
8251   DECL_EXTERNAL (decl) = 1;
8252   DECL_ARTIFICIAL (decl) = 1;
8253   pushdecl (decl);
8254   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
8255   pop_from_top_level ();
8256
8257   return decl;
8258 }
8259
8260 /* Returns a pointer to the `atexit' function.  Note that if
8261    FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
8262    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
8263
8264 static tree
8265 get_atexit_node ()
8266 {
8267   tree atexit_fndecl;
8268   tree arg_types;
8269   tree fn_type;
8270   tree fn_ptr_type;
8271   const char *name;
8272
8273   if (atexit_node)
8274     return atexit_node;
8275
8276   if (flag_use_cxa_atexit)
8277     {
8278       /* The declaration for `__cxa_atexit' is:
8279
8280            int __cxa_atexit (void (*)(void *), void *, void *)
8281
8282          We build up the argument types and then then function type
8283          itself.  */
8284
8285       /* First, build the pointer-to-function type for the first
8286          argument.  */
8287       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8288       fn_type = build_function_type (void_type_node, arg_types);
8289       fn_ptr_type = build_pointer_type (fn_type);
8290       /* Then, build the rest of the argument types.  */
8291       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8292       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
8293       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
8294       /* And the final __cxa_atexit type.  */
8295       fn_type = build_function_type (integer_type_node, arg_types);
8296       fn_ptr_type = build_pointer_type (fn_type);
8297       name = "__cxa_atexit";
8298     }
8299   else
8300     {
8301       /* The declaration for `atexit' is:
8302
8303            int atexit (void (*)());
8304
8305          We build up the argument types and then then function type
8306          itself.  */
8307       fn_type = build_function_type (void_type_node, void_list_node);
8308       fn_ptr_type = build_pointer_type (fn_type);
8309       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
8310       /* Build the final atexit type.  */
8311       fn_type = build_function_type (integer_type_node, arg_types);
8312       name = "atexit";
8313     }
8314
8315   /* Now, build the function declaration.  */
8316   push_lang_context (lang_name_c);
8317   atexit_fndecl = build_library_fn_ptr (name, fn_type);
8318   mark_used (atexit_fndecl);
8319   pop_lang_context ();
8320   atexit_node = default_conversion (atexit_fndecl);
8321
8322   return atexit_node;
8323 }
8324
8325 /* Returns the __dso_handle VAR_DECL.  */
8326
8327 static tree
8328 get_dso_handle_node ()
8329 {
8330   if (dso_handle_node)
8331     return dso_handle_node;
8332
8333   /* Declare the variable.  */
8334   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8335                                         ptr_type_node);
8336
8337   return dso_handle_node;
8338 }
8339
8340 /* Begin a new function with internal linkage whose job will be simply
8341    to destroy some particular variable.  */
8342
8343 static tree
8344 start_cleanup_fn ()
8345 {
8346   static int counter = 0;
8347   int old_interface_unknown = interface_unknown;
8348   char name[32];
8349   tree parmtypes;
8350   tree fntype;
8351   tree fndecl;
8352
8353   push_to_top_level ();
8354
8355   /* No need to mangle this.  */
8356   push_lang_context (lang_name_c);
8357
8358   interface_unknown = 1;
8359
8360   /* Build the parameter-types.  */
8361   parmtypes = void_list_node;
8362   /* Functions passed to __cxa_atexit take an additional parameter.
8363      We'll just ignore it.  After we implement the new calling
8364      convention for destructors, we can eliminate the use of
8365      additional cleanup functions entirely in the -fnew-abi case.  */
8366   if (flag_use_cxa_atexit)
8367     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8368   /* Build the function type itself.  */
8369   fntype = build_function_type (void_type_node, parmtypes);
8370   /* Build the name of the function.  */
8371   sprintf (name, "__tcf_%d", counter++);
8372   /* Build the function declaration.  */
8373   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8374   /* It's a function with internal linkage, generated by the
8375      compiler.  */
8376   TREE_PUBLIC (fndecl) = 0;
8377   DECL_ARTIFICIAL (fndecl) = 1;
8378   /* Make the function `inline' so that it is only emitted if it is
8379      actually needed.  It is unlikely that it will be inlined, since
8380      it is only called via a function pointer, but we avoid unncessary
8381      emissions this way.  */
8382   DECL_INLINE (fndecl) = 1;
8383   /* Build the parameter.  */
8384   if (flag_use_cxa_atexit)
8385     {
8386       tree parmdecl;
8387
8388       parmdecl = build_decl (PARM_DECL, NULL_TREE, ptr_type_node);
8389       DECL_CONTEXT (parmdecl) = fndecl;
8390       DECL_ARG_TYPE (parmdecl) = ptr_type_node;
8391       TREE_USED (parmdecl) = 1;
8392       DECL_ARGUMENTS (fndecl) = parmdecl;
8393     }
8394
8395   pushdecl (fndecl);
8396   start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8397   do_pushlevel ();
8398
8399   interface_unknown = old_interface_unknown;
8400
8401   pop_lang_context ();
8402
8403   return current_function_decl;
8404 }
8405
8406 /* Finish the cleanup function begun by start_cleanup_fn.  */
8407
8408 static void
8409 end_cleanup_fn ()
8410 {
8411   do_poplevel ();
8412
8413   expand_body (finish_function (0));
8414
8415   pop_from_top_level ();
8416 }
8417
8418 /* Generate code to handle the destruction of DECL, an object with
8419    static storage duration.  */
8420
8421 void
8422 register_dtor_fn (decl)
8423      tree decl;
8424 {
8425   tree cleanup;
8426   tree compound_stmt;
8427   tree args;
8428   tree fcall;
8429
8430   int saved_flag_access_control;
8431
8432   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8433     return;
8434
8435   /* Call build_cleanup before we enter the anonymous function so that
8436      any access checks will be done relative to the current scope,
8437      rather than the scope of the anonymous function.  */
8438   build_cleanup (decl);
8439
8440   /* Now start the function.  */
8441   cleanup = start_cleanup_fn ();
8442
8443   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
8444      to the original function, rather than the anonymous one.  That
8445      will make the back-end think that nested functions are in use,
8446      which causes confusion.  */
8447   saved_flag_access_control = flag_access_control;
8448   flag_access_control = 0;
8449   fcall = build_cleanup (decl);
8450   flag_access_control = saved_flag_access_control;
8451
8452   /* Create the body of the anonymous function.  */
8453   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8454   finish_expr_stmt (fcall);
8455   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8456   end_cleanup_fn ();
8457
8458   /* Call atexit with the cleanup function.  */
8459   mark_addressable (cleanup);
8460   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8461   if (flag_use_cxa_atexit)
8462     {
8463       args = tree_cons (NULL_TREE, get_dso_handle_node (), NULL_TREE);
8464       args = tree_cons (NULL_TREE, null_pointer_node, args);
8465       args = tree_cons (NULL_TREE, cleanup, args);
8466     }
8467   else
8468     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8469   finish_expr_stmt (build_function_call (get_atexit_node (), args));
8470 }
8471
8472 void
8473 expand_static_init (decl, init)
8474      tree decl;
8475      tree init;
8476 {
8477   tree oldstatic = value_member (decl, static_aggregates);
8478
8479   if (oldstatic)
8480     {
8481       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8482         cp_error ("multiple initializations given for `%D'", decl);
8483     }
8484   else if (! toplevel_bindings_p ())
8485     {
8486       /* Emit code to perform this initialization but once.  */
8487       tree if_stmt;
8488       tree then_clause;
8489       tree assignment;
8490       tree guard;
8491       tree guard_init;
8492
8493       /* Emit code to perform this initialization but once.  This code
8494          looks like:
8495
8496            static int guard = 0;
8497            if (!guard) {
8498              // Do initialization.
8499              guard = 1;
8500              // Register variable for destruction at end of program.
8501            }
8502
8503          Note that the `temp' variable is only set to 1 *after* the
8504          initialization is complete.  This ensures that an exception,
8505          thrown during the construction, will cause the variable to
8506          reinitialized when we pass through this code again, as per:
8507
8508            [stmt.dcl]
8509
8510            If the initialization exits by throwing an exception, the
8511            initialization is not complete, so it will be tried again
8512            the next time control enters the declaration.
8513
8514          In theory, this process should be thread-safe, too; multiple
8515          threads should not be able to initialize the variable more
8516          than once.  We don't yet attempt to ensure thread-safety.  */
8517
8518       /* Create the guard variable.  */
8519       guard = get_guard (decl);
8520
8521       /* Begin the conditional initialization.  */
8522       if_stmt = begin_if_stmt ();
8523       finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
8524       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8525
8526       /* Do the initialization itself.  */
8527       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8528           || (init && TREE_CODE (init) == TREE_LIST))
8529         assignment = build_aggr_init (decl, init, 0);
8530       else if (init)
8531         /* The initialization we're doing here is just a bitwise
8532            copy.  */
8533         assignment = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
8534       else
8535         assignment = NULL_TREE;
8536
8537       /* Once the assignment is complete, set TEMP to 1.  Since the
8538          construction of the static object is complete at this point,
8539          we want to make sure TEMP is set to 1 even if a temporary
8540          constructed during the initialization throws an exception
8541          when it is destroyed.  So, we combine the initialization and
8542          the assignment to TEMP into a single expression, ensuring
8543          that when we call finish_expr_stmt the cleanups will not be
8544          run until after TEMP is set to 1.  */
8545       guard_init = set_guard (guard);
8546       if (assignment)
8547         {
8548           assignment = tree_cons (NULL_TREE, assignment,
8549                                   build_tree_list (NULL_TREE,
8550                                                    guard_init));
8551           assignment = build_compound_expr (assignment);
8552         }
8553       else
8554         assignment = guard_init;
8555       finish_expr_stmt (assignment);
8556
8557       /* Use atexit to register a function for destroying this static
8558          variable.  */
8559       register_dtor_fn (decl);
8560
8561       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8562       finish_then_clause (if_stmt);
8563       finish_if_stmt ();
8564     }
8565   else
8566     static_aggregates = tree_cons (init, decl, static_aggregates);
8567 }
8568
8569 /* Finish the declaration of a catch-parameter.  */
8570
8571 tree
8572 start_handler_parms (declspecs, declarator)
8573      tree declspecs;
8574      tree declarator;
8575 {
8576   tree decl;
8577   if (declspecs)
8578     {
8579       decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8580                              1, NULL_TREE);
8581       if (decl == NULL_TREE)
8582         error ("invalid catch parameter");
8583     }
8584   else
8585     decl = NULL_TREE;
8586
8587   return decl;
8588 }
8589
8590 \f
8591 /* Make TYPE a complete type based on INITIAL_VALUE.
8592    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8593    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
8594
8595 int
8596 complete_array_type (type, initial_value, do_default)
8597      tree type, initial_value;
8598      int do_default;
8599 {
8600   register tree maxindex = NULL_TREE;
8601   int value = 0;
8602
8603   if (initial_value)
8604     {
8605       /* An array of character type can be initialized from a
8606          brace-enclosed string constant.  */
8607       if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))
8608           && TREE_CODE (initial_value) == CONSTRUCTOR
8609           && CONSTRUCTOR_ELTS (initial_value)
8610           && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value)))
8611               == STRING_CST)
8612           && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value)) == NULL_TREE)
8613         initial_value = TREE_VALUE (CONSTRUCTOR_ELTS (initial_value));
8614
8615       /* Note MAXINDEX is really the maximum index, one less than the
8616          size.  */
8617       if (TREE_CODE (initial_value) == STRING_CST)
8618         {
8619           int eltsize
8620             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8621           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8622                                    / eltsize) - 1, 0);
8623         }
8624       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8625         {
8626           tree elts = CONSTRUCTOR_ELTS (initial_value);
8627
8628           maxindex = ssize_int (-1);
8629           for (; elts; elts = TREE_CHAIN (elts))
8630             {
8631               if (TREE_PURPOSE (elts))
8632                 maxindex = TREE_PURPOSE (elts);
8633               else
8634                 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
8635             }
8636           maxindex = copy_node (maxindex);
8637         }
8638       else
8639         {
8640           /* Make an error message unless that happened already.  */
8641           if (initial_value != error_mark_node)
8642             value = 1;
8643           else
8644             initial_value = NULL_TREE;
8645
8646           /* Prevent further error messages.  */
8647           maxindex = build_int_2 (0, 0);
8648         }
8649     }
8650
8651   if (!maxindex)
8652     {
8653       if (do_default)
8654         maxindex = build_int_2 (0, 0);
8655       value = 2;
8656     }
8657
8658   if (maxindex)
8659     {
8660       tree itype;
8661       tree domain;
8662
8663       domain = build_index_type (maxindex);
8664       TYPE_DOMAIN (type) = domain;
8665
8666       if (! TREE_TYPE (maxindex))
8667         TREE_TYPE (maxindex) = domain;
8668       if (initial_value)
8669         itype = TREE_TYPE (initial_value);
8670       else
8671         itype = NULL;
8672       if (itype && !TYPE_DOMAIN (itype))
8673         TYPE_DOMAIN (itype) = domain;
8674       /* The type of the main variant should never be used for arrays
8675          of different sizes.  It should only ever be completed with the
8676          size of the array.  */
8677       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8678         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8679     }
8680
8681   /* Lay out the type now that we can get the real answer.  */
8682
8683   layout_type (type);
8684
8685   return value;
8686 }
8687 \f
8688 /* Return zero if something is declared to be a member of type
8689    CTYPE when in the context of CUR_TYPE.  STRING is the error
8690    message to print in that case.  Otherwise, quietly return 1.  */
8691
8692 static int
8693 member_function_or_else (ctype, cur_type, flags)
8694      tree ctype, cur_type;
8695      enum overload_flags flags;
8696 {
8697   if (ctype && ctype != cur_type)
8698     {
8699       if (flags == DTOR_FLAG)
8700         error ("destructor for alien class `%s' cannot be a member",
8701                TYPE_NAME_STRING (ctype));
8702       else
8703         error ("constructor for alien class `%s' cannot be a member",
8704                TYPE_NAME_STRING (ctype));
8705       return 0;
8706     }
8707   return 1;
8708 }
8709 \f
8710 /* Subroutine of `grokdeclarator'.  */
8711
8712 /* Generate errors possibly applicable for a given set of specifiers.
8713    This is for ARM $7.1.2.  */
8714
8715 static void
8716 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8717      tree object;
8718      const char *type;
8719      int virtualp, quals, friendp, raises, inlinep;
8720 {
8721   if (virtualp)
8722     cp_error ("`%D' declared as a `virtual' %s", object, type);
8723   if (inlinep)
8724     cp_error ("`%D' declared as an `inline' %s", object, type);
8725   if (quals)
8726     cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8727               object, type);
8728   if (friendp)
8729     cp_error_at ("`%D' declared as a friend", object);
8730   if (raises)
8731     cp_error_at ("`%D' declared with an exception specification", object);
8732 }
8733
8734 /* CTYPE is class type, or null if non-class.
8735    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8736    or METHOD_TYPE.
8737    DECLARATOR is the function's name.
8738    VIRTUALP is truthvalue of whether the function is virtual or not.
8739    FLAGS are to be passed through to `grokclassfn'.
8740    QUALS are qualifiers indicating whether the function is `const'
8741    or `volatile'.
8742    RAISES is a list of exceptions that this function can raise.
8743    CHECK is 1 if we must find this method in CTYPE, 0 if we should
8744    not look, and -1 if we should not call `grokclassfn' at all.
8745
8746    Returns `NULL_TREE' if something goes wrong, after issuing
8747    applicable error messages.  */
8748
8749 static tree
8750 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8751             raises, check, friendp, publicp, inlinep, funcdef_flag,
8752             template_count, in_namespace)
8753      tree ctype, type;
8754      tree declarator;
8755      tree orig_declarator;
8756      int virtualp;
8757      enum overload_flags flags;
8758      tree quals, raises;
8759      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8760      tree in_namespace;
8761 {
8762   tree cname, decl;
8763   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8764   int has_default_arg = 0;
8765   tree t;
8766
8767   if (ctype)
8768     cname = TREE_CODE (TYPE_NAME (ctype)) == TYPE_DECL
8769       ? TYPE_IDENTIFIER (ctype) : TYPE_NAME (ctype);
8770   else
8771     cname = NULL_TREE;
8772
8773   if (raises)
8774     {
8775       type = build_exception_variant (type, raises);
8776     }
8777
8778   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8779   /* Propagate volatile out from type to decl. */
8780   if (TYPE_VOLATILE (type))
8781     TREE_THIS_VOLATILE (decl) = 1;
8782
8783   /* If this decl has namespace scope, set that up.  */
8784   if (in_namespace)
8785     set_decl_namespace (decl, in_namespace, friendp);
8786   else if (!ctype)
8787     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8788
8789   /* `main' and builtins have implicit 'C' linkage.  */
8790   if ((MAIN_NAME_P (declarator)
8791        || (IDENTIFIER_LENGTH (declarator) > 10
8792            && IDENTIFIER_POINTER (declarator)[0] == '_'
8793            && IDENTIFIER_POINTER (declarator)[1] == '_'
8794            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8795       && current_lang_name == lang_name_cplusplus
8796       && ctype == NULL_TREE
8797       /* NULL_TREE means global namespace.  */
8798       && DECL_CONTEXT (decl) == NULL_TREE)
8799     DECL_LANGUAGE (decl) = lang_c;
8800
8801   /* Should probably propagate const out from type to decl I bet (mrs).  */
8802   if (staticp)
8803     {
8804       DECL_STATIC_FUNCTION_P (decl) = 1;
8805       DECL_CONTEXT (decl) = ctype;
8806     }
8807
8808   if (ctype)
8809     DECL_CONTEXT (decl) = ctype;
8810
8811   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8812     {
8813       if (processing_template_decl)
8814         error ("cannot declare `::main' to be a template");
8815       if (inlinep)
8816         error ("cannot declare `::main' to be inline");
8817       else if (! publicp)
8818         error ("cannot declare `::main' to be static");
8819       inlinep = 0;
8820       publicp = 1;
8821     }
8822
8823   /* Members of anonymous types and local classes have no linkage; make
8824      them internal.  */
8825   if (ctype && (ANON_AGGRNAME_P (TYPE_IDENTIFIER (ctype))
8826                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
8827     publicp = 0;
8828
8829   if (publicp)
8830     {
8831       /* [basic.link]: A name with no linkage (notably, the name of a class
8832          or enumeration declared in a local scope) shall not be used to
8833          declare an entity with linkage.
8834
8835          Only check this for public decls for now.  */
8836       t = no_linkage_check (TREE_TYPE (decl));
8837       if (t)
8838         {
8839           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8840             {
8841               if (DECL_EXTERN_C_P (decl))
8842                 /* Allow this; it's pretty common in C.  */;
8843               else
8844                 cp_pedwarn ("non-local function `%#D' uses anonymous type",
8845                             decl);
8846             }
8847           else
8848             cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8849                         decl, t);
8850         }
8851     }
8852
8853   TREE_PUBLIC (decl) = publicp;
8854   if (! publicp)
8855     {
8856       DECL_INTERFACE_KNOWN (decl) = 1;
8857       DECL_NOT_REALLY_EXTERN (decl) = 1;
8858     }
8859
8860   if (inlinep)
8861     DECL_THIS_INLINE (decl) = DECL_INLINE (decl) = 1;
8862
8863   DECL_EXTERNAL (decl) = 1;
8864   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
8865     {
8866       cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8867                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
8868       quals = NULL_TREE;
8869     }
8870
8871   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
8872     grok_op_properties (decl, virtualp, check < 0);
8873
8874   if (ctype && decl_function_context (decl))
8875     DECL_NO_STATIC_CHAIN (decl) = 1;
8876
8877   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
8878     if (TREE_PURPOSE (t)
8879         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
8880       {
8881         has_default_arg = 1;
8882         break;
8883       }
8884
8885   if (friendp
8886       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
8887     {
8888       if (funcdef_flag)
8889         cp_error
8890           ("defining explicit specialization `%D' in friend declaration",
8891            orig_declarator);
8892       else
8893         {
8894           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8895             {
8896               /* Something like `template <class T> friend void f<T>()'.  */
8897               cp_error ("invalid use of template-id `%D' in declaration of primary template",
8898                         orig_declarator);
8899               return NULL_TREE;
8900             }
8901
8902
8903           /* A friend declaration of the form friend void f<>().  Record
8904              the information in the TEMPLATE_ID_EXPR.  */
8905           SET_DECL_IMPLICIT_INSTANTIATION (decl);
8906           DECL_TEMPLATE_INFO (decl)
8907             = tree_cons (TREE_OPERAND (orig_declarator, 0),
8908                          TREE_OPERAND (orig_declarator, 1),
8909                          NULL_TREE);
8910
8911           if (has_default_arg)
8912             {
8913               cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8914                         decl);
8915               return NULL_TREE;
8916             }
8917
8918           if (inlinep)
8919             {
8920               cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
8921                         decl);
8922               return NULL_TREE;
8923             }
8924         }
8925     }
8926
8927   if (has_default_arg)
8928     add_defarg_fn (decl);
8929
8930   /* Plain overloading: will not be grok'd by grokclassfn.  */
8931   if (! ctype && ! processing_template_decl
8932       && !DECL_EXTERN_C_P (decl)
8933       && (! DECL_USE_TEMPLATE (decl) || name_mangling_version < 1))
8934     set_mangled_name_for_decl (decl);
8935
8936   if (funcdef_flag)
8937     /* Make the init_value nonzero so pushdecl knows this is not
8938        tentative.  error_mark_node is replaced later with the BLOCK.  */
8939     DECL_INITIAL (decl) = error_mark_node;
8940
8941   if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
8942     TREE_NOTHROW (decl) = 1;
8943
8944   /* Caller will do the rest of this.  */
8945   if (check < 0)
8946     return decl;
8947
8948   if (flags == NO_SPECIAL && ctype && constructor_name (cname) == declarator)
8949     DECL_CONSTRUCTOR_P (decl) = 1;
8950
8951   /* Function gets the ugly name, field gets the nice one.  This call
8952      may change the type of the function (because of default
8953      parameters)!  */
8954   if (ctype != NULL_TREE)
8955     grokclassfn (ctype, decl, flags, quals);
8956
8957   decl = check_explicit_specialization (orig_declarator, decl,
8958                                         template_count,
8959                                         2 * (funcdef_flag != 0) +
8960                                         4 * (friendp != 0));
8961   if (decl == error_mark_node)
8962     return NULL_TREE;
8963
8964   if (ctype != NULL_TREE
8965       && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
8966       && check)
8967     {
8968       tree old_decl;
8969
8970       old_decl = check_classfn (ctype, decl);
8971
8972       if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
8973         /* Because grokfndecl is always supposed to return a
8974            FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
8975            here.  We depend on our callers to figure out that its
8976            really a template that's being returned.  */
8977         old_decl = DECL_TEMPLATE_RESULT (old_decl);
8978
8979       if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
8980           && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
8981         {
8982           /* Remove the `this' parm added by grokclassfn.
8983              XXX Isn't this done in start_function, too?  */
8984           revert_static_member_fn (decl);
8985           last_function_parms = TREE_CHAIN (last_function_parms);
8986         }
8987       if (old_decl && DECL_ARTIFICIAL (old_decl))
8988         cp_error ("definition of implicitly-declared `%D'", old_decl);
8989
8990       if (old_decl)
8991         {
8992           /* Since we've smashed OLD_DECL to its
8993              DECL_TEMPLATE_RESULT, we must do the same to DECL.  */
8994           if (TREE_CODE (decl) == TEMPLATE_DECL)
8995             decl = DECL_TEMPLATE_RESULT (decl);
8996
8997           /* Attempt to merge the declarations.  This can fail, in
8998              the case of some illegal specialization declarations.  */
8999           if (!duplicate_decls (decl, old_decl))
9000             cp_error ("no `%#D' member function declared in class `%T'",
9001                       decl, ctype);
9002           return old_decl;
9003         }
9004     }
9005
9006   if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
9007     return NULL_TREE;
9008
9009   if (ctype == NULL_TREE || check)
9010     return decl;
9011
9012   if (virtualp)
9013     {
9014       DECL_VIRTUAL_P (decl) = 1;
9015       if (DECL_VINDEX (decl) == NULL_TREE)
9016         DECL_VINDEX (decl) = error_mark_node;
9017       IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
9018     }
9019
9020   return decl;
9021 }
9022
9023 static tree
9024 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
9025      tree type;
9026      tree declarator;
9027      RID_BIT_TYPE *specbits_in;
9028      int initialized;
9029      int constp;
9030      tree in_namespace;
9031 {
9032   tree decl;
9033   RID_BIT_TYPE specbits;
9034
9035   specbits = *specbits_in;
9036
9037   if (TREE_CODE (type) == OFFSET_TYPE)
9038     {
9039       /* If you declare a static member so that it
9040          can be initialized, the code will reach here.  */
9041       tree basetype = TYPE_OFFSET_BASETYPE (type);
9042       type = TREE_TYPE (type);
9043       decl = build_lang_decl (VAR_DECL, declarator, type);
9044       DECL_CONTEXT (decl) = basetype;
9045       /* DECL_ASSEMBLER_NAME is needed only for full-instantiated
9046          templates.  */
9047       if (!uses_template_parms (decl))
9048         {
9049           if (flag_new_abi)
9050             DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
9051           else
9052             DECL_ASSEMBLER_NAME (decl) = build_static_name (basetype,
9053                                                             declarator);
9054         }
9055     }
9056   else
9057     {
9058       tree context;
9059
9060       if (in_namespace)
9061         context = in_namespace;
9062       else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
9063         context = current_namespace;
9064       else
9065         context = NULL_TREE;
9066
9067       if (processing_template_decl && context)
9068         /* For global variables, declared in a template, we need the
9069            full lang_decl.  */
9070         decl = build_lang_decl (VAR_DECL, declarator, type);
9071       else
9072         decl = build_decl (VAR_DECL, declarator, type);
9073
9074       if (context)
9075         set_decl_namespace (decl, context, 0);
9076
9077       context = DECL_CONTEXT (decl);
9078       if (declarator && context && current_lang_name != lang_name_c)
9079         {
9080           if (flag_new_abi)
9081             DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
9082           else
9083             DECL_ASSEMBLER_NAME (decl)
9084               = build_static_name (context, declarator);
9085         }
9086     }
9087
9088   if (in_namespace)
9089     set_decl_namespace (decl, in_namespace, 0);
9090
9091   if (RIDBIT_SETP (RID_EXTERN, specbits))
9092     {
9093       DECL_THIS_EXTERN (decl) = 1;
9094       DECL_EXTERNAL (decl) = !initialized;
9095     }
9096
9097   /* In class context, static means one per class,
9098      public access, and static storage.  */
9099   if (DECL_CLASS_SCOPE_P (decl))
9100     {
9101       TREE_PUBLIC (decl) = 1;
9102       TREE_STATIC (decl) = 1;
9103       DECL_EXTERNAL (decl) = 0;
9104     }
9105   /* At top level, either `static' or no s.c. makes a definition
9106      (perhaps tentative), and absence of `static' makes it public.  */
9107   else if (toplevel_bindings_p ())
9108     {
9109       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
9110                             && (DECL_THIS_EXTERN (decl) || ! constp));
9111       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
9112     }
9113   /* Not at top level, only `static' makes a static definition.  */
9114   else
9115     {
9116       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
9117       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
9118     }
9119
9120   if (TREE_PUBLIC (decl))
9121     {
9122       /* [basic.link]: A name with no linkage (notably, the name of a class
9123          or enumeration declared in a local scope) shall not be used to
9124          declare an entity with linkage.
9125
9126          Only check this for public decls for now.  */
9127       tree t = no_linkage_check (TREE_TYPE (decl));
9128       if (t)
9129         {
9130           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
9131             /* Ignore for now; `enum { foo } e' is pretty common.  */;
9132           else
9133             cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
9134                         decl, t);
9135         }
9136     }
9137
9138   return decl;
9139 }
9140
9141 /* Create and return a canonical pointer to member function type, for
9142    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
9143
9144 tree
9145 build_ptrmemfunc_type (type)
9146      tree type;
9147 {
9148   tree fields[4];
9149   tree t;
9150   tree u;
9151   tree unqualified_variant = NULL_TREE;
9152
9153   /* If a canonical type already exists for this type, use it.  We use
9154      this method instead of type_hash_canon, because it only does a
9155      simple equality check on the list of field members.  */
9156
9157   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
9158     return t;
9159
9160   /* Make sure that we always have the unqualified pointer-to-member
9161      type first.  */
9162   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9163     unqualified_variant
9164       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
9165
9166   t = make_aggr_type (RECORD_TYPE);
9167   /* Let the front-end know this is a pointer to member function...  */
9168   TYPE_PTRMEMFUNC_FLAG (t) = 1;
9169   /* ... and not really an aggregate.  */
9170   SET_IS_AGGR_TYPE (t, 0);
9171
9172   if (!flag_new_abi)
9173     {
9174       u = make_aggr_type (UNION_TYPE);
9175       SET_IS_AGGR_TYPE (u, 0);
9176       fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9177       fields[1] = build_decl (FIELD_DECL, delta2_identifier,
9178                               delta_type_node);
9179       finish_builtin_type (u, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9180       TYPE_NAME (u) = NULL_TREE;
9181
9182       fields[0] = build_decl (FIELD_DECL, delta_identifier,
9183                               delta_type_node);
9184       fields[1] = build_decl (FIELD_DECL, index_identifier,
9185                               delta_type_node);
9186       fields[2] = build_decl (FIELD_DECL, pfn_or_delta2_identifier, u);
9187       finish_builtin_type (t, "__ptrmemfunc_type", fields, 2, ptr_type_node);
9188     }
9189   else
9190     {
9191       fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9192       fields[1] = build_decl (FIELD_DECL, delta_identifier,
9193                               delta_type_node);
9194       finish_builtin_type (t, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9195     }
9196
9197   /* Zap out the name so that the back-end will give us the debugging
9198      information for this anonymous RECORD_TYPE.  */
9199   TYPE_NAME (t) = NULL_TREE;
9200
9201   /* If this is not the unqualified form of this pointer-to-member
9202      type, set the TYPE_MAIN_VARIANT for this type to be the
9203      unqualified type.  Since they are actually RECORD_TYPEs that are
9204      not variants of each other, we must do this manually.  */
9205   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9206     {
9207       t = build_qualified_type (t, CP_TYPE_QUALS (type));
9208       TYPE_MAIN_VARIANT (t) = unqualified_variant;
9209       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
9210       TYPE_NEXT_VARIANT (unqualified_variant) = t;
9211     }
9212
9213   /* Cache this pointer-to-member type so that we can find it again
9214      later.  */
9215   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
9216
9217   /* Seems to be wanted.  */
9218   CLASSTYPE_GOT_SEMICOLON (t) = 1;
9219
9220   return t;
9221 }
9222
9223 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9224    Check to see that the definition is valid.  Issue appropriate error
9225    messages.  Return 1 if the definition is particularly bad, or 0
9226    otherwise.  */
9227
9228 int
9229 check_static_variable_definition (decl, type)
9230      tree decl;
9231      tree type;
9232 {
9233   /* Motion 10 at San Diego: If a static const integral data member is
9234      initialized with an integral constant expression, the initializer
9235      may appear either in the declaration (within the class), or in
9236      the definition, but not both.  If it appears in the class, the
9237      member is a member constant.  The file-scope definition is always
9238      required.  */
9239   if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
9240     {
9241       cp_error ("invalid in-class initialization of static data member of non-integral type `%T'",
9242                 type);
9243       /* If we just return the declaration, crashes will sometimes
9244          occur.  We therefore return void_type_node, as if this was a
9245          friend declaration, to cause callers to completely ignore
9246          this declaration.  */
9247       return 1;
9248     }
9249   else if (!CP_TYPE_CONST_P (type))
9250     cp_error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9251               decl);
9252   else if (pedantic && !INTEGRAL_TYPE_P (type))
9253     cp_pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
9254
9255   return 0;
9256 }
9257
9258 /* Given the SIZE (i.e., number of elements) in an array, compute an
9259    appropriate index type for the array.  If non-NULL, NAME is the
9260    name of the thing being declared.  */
9261
9262 tree
9263 compute_array_index_type (name, size)
9264      tree name;
9265      tree size;
9266 {
9267   tree itype;
9268
9269   /* The size might be the result of a cast. */
9270   STRIP_TYPE_NOPS (size);
9271
9272   /* It might be a const variable or enumeration constant.  */
9273   size = decl_constant_value (size);
9274
9275   /* If this involves a template parameter, it will be a constant at
9276      instantiation time, but we don't know what the value is yet.
9277      Even if no template parameters are involved, we may an expression
9278      that is not a constant; we don't even simplify `1 + 2' when
9279      processing a template.  */
9280   if (processing_template_decl)
9281     {
9282       /* Resolve a qualified reference to an enumerator or static
9283          const data member of ours.  */
9284       if (TREE_CODE (size) == SCOPE_REF
9285           && TREE_OPERAND (size, 0) == current_class_type)
9286         {
9287           tree t = lookup_field (current_class_type,
9288                                  TREE_OPERAND (size, 1), 0, 0);
9289           if (t)
9290             size = t;
9291         }
9292
9293       return build_index_type (build_min (MINUS_EXPR, sizetype,
9294                                           size, integer_one_node));
9295     }
9296
9297   /* The array bound must be an integer type.  */
9298   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9299       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
9300       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
9301     {
9302       if (name)
9303         cp_error ("size of array `%D' has non-integer type", name);
9304       else
9305         cp_error ("size of array has non-integer type");
9306       size = integer_one_node;
9307     }
9308
9309   /* Normally, the array-bound will be a constant.  */
9310   if (TREE_CODE (size) == INTEGER_CST)
9311     {
9312       /* Check to see if the array bound overflowed.  Make that an
9313          error, no matter how generous we're being.  */
9314       int old_flag_pedantic_errors = flag_pedantic_errors;
9315       int old_pedantic = pedantic;
9316       pedantic = flag_pedantic_errors = 1;
9317       constant_expression_warning (size);
9318       pedantic = old_pedantic;
9319       flag_pedantic_errors = old_flag_pedantic_errors;
9320
9321       /* An array must have a positive number of elements.  */
9322       if (INT_CST_LT (size, integer_zero_node))
9323         {
9324           if (name)
9325             cp_error ("size of array `%D' is negative", name);
9326           else
9327             cp_error ("size of array is negative");
9328           size = integer_one_node;
9329         }
9330       /* Except that an extension we allow zero-sized arrays.  We
9331          always allow them in system headers because glibc uses
9332          them.  */
9333       else if (integer_zerop (size) && pedantic && !in_system_header)
9334         {
9335           if (name)
9336             cp_pedwarn ("ISO C++ forbids zero-size array `%D'", name);
9337           else
9338             cp_pedwarn ("ISO C++ forbids zero-size array");
9339         }
9340     }
9341   else if (TREE_CONSTANT (size))
9342     {
9343       /* `(int) &fn' is not a valid array bound.  */
9344       if (name)
9345         cp_error ("size of array `%D' is not an integral constant-expression",
9346                   name);
9347       else
9348         cp_error ("size of array is not an integral constant-expression");
9349     }
9350
9351   /* Compute the index of the largest element in the array.  It is
9352      one less than the number of elements in the array.  */
9353   itype
9354     = fold (cp_build_binary_op (MINUS_EXPR,
9355                                 cp_convert (ssizetype, size),
9356                                 cp_convert (ssizetype,
9357                                             integer_one_node)));
9358
9359   /* Check for variable-sized arrays.  We allow such things as an
9360      extension, even though they are not allowed in ANSI/ISO C++.  */
9361   if (!TREE_CONSTANT (itype))
9362     {
9363       if (pedantic)
9364         {
9365           if (name)
9366             cp_pedwarn ("ISO C++ forbids variable-size array `%D'",
9367                         name);
9368           else
9369             cp_pedwarn ("ISO C++ forbids variable-size array");
9370         }
9371
9372       /* Create a variable-sized array index type.  */
9373       itype = variable_size (itype);
9374     }
9375   /* Make sure that there was no overflow when creating to a signed
9376      index type.  (For example, on a 32-bit machine, an array with
9377      size 2^32 - 1 is too big.)  */
9378   else if (TREE_OVERFLOW (itype))
9379     {
9380       error ("overflow in array dimension");
9381       TREE_OVERFLOW (itype) = 0;
9382     }
9383
9384   /* Create and return the appropriate index type.  */
9385   return build_index_type (itype);
9386 }
9387
9388 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9389    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
9390    with this type.  */
9391
9392 static tree
9393 create_array_type_for_decl (name, type, size)
9394      tree name;
9395      tree type;
9396      tree size;
9397 {
9398   tree itype = NULL_TREE;
9399   const char* error_msg;
9400
9401   /* If things have already gone awry, bail now.  */
9402   if (type == error_mark_node || size == error_mark_node)
9403     return error_mark_node;
9404
9405   /* Assume that everything will go OK.  */
9406   error_msg = NULL;
9407
9408   /* There are some types which cannot be array elements.  */
9409   switch (TREE_CODE (type))
9410     {
9411     case VOID_TYPE:
9412       error_msg = "array of void";
9413       break;
9414
9415     case FUNCTION_TYPE:
9416       error_msg = "array of functions";
9417       break;
9418
9419     case REFERENCE_TYPE:
9420       error_msg = "array of references";
9421       break;
9422
9423     case OFFSET_TYPE:
9424       error_msg = "array of data members";
9425       break;
9426
9427     case METHOD_TYPE:
9428       error_msg = "array of function members";
9429       break;
9430
9431     default:
9432       break;
9433     }
9434
9435   /* If something went wrong, issue an error-message and return.  */
9436   if (error_msg)
9437     {
9438       if (name)
9439         cp_error ("declaration of `%D' as %s", name, error_msg);
9440       else
9441         cp_error ("creating %s", error_msg);
9442
9443       return error_mark_node;
9444     }
9445
9446   /* [dcl.array]
9447
9448      The constant expressions that specify the bounds of the arrays
9449      can be omitted only for the first member of the sequence.  */
9450   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9451     {
9452       cp_error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9453                 name);
9454
9455       return error_mark_node;
9456     }
9457
9458   /* Figure out the index type for the array.  */
9459   if (size)
9460     itype = compute_array_index_type (name, size);
9461
9462   return build_cplus_array_type (type, itype);
9463 }
9464
9465 /* Check that it's OK to declare a function with the indicated TYPE.
9466    SFK indicates the kind of special function (if any) that this
9467    function is.  CTYPE is the class of which this function is a
9468    member.  OPTYPE is the type given in a conversion operator
9469    declaration.  Returns the actual return type of the function; that
9470    may be different than TYPE if an error occurs, or for certain
9471    special functions.  */
9472
9473 static tree
9474 check_special_function_return_type (sfk, type, ctype, optype)
9475      special_function_kind sfk;
9476      tree type;
9477      tree ctype;
9478      tree optype;
9479 {
9480   switch (sfk)
9481     {
9482     case sfk_constructor:
9483       if (type)
9484         cp_error ("return type specification for constructor invalid");
9485
9486       /* In the old ABI, we return `this'; in the new ABI we don't
9487          bother.  */
9488       type = flag_new_abi ? void_type_node : build_pointer_type (ctype);
9489       break;
9490
9491     case sfk_destructor:
9492       if (type)
9493         cp_error ("return type specification for destructor invalid");
9494       type = void_type_node;
9495       break;
9496
9497     case sfk_conversion:
9498       if (type && !same_type_p (type, optype))
9499         cp_error ("operator `%T' declared to return `%T'", optype, type);
9500       else if (type)
9501         cp_pedwarn ("return type specified for `operator %T'",  optype);
9502       type = optype;
9503       break;
9504
9505     default:
9506       my_friendly_abort (20000408);
9507       break;
9508     }
9509
9510   return type;
9511 }
9512
9513 /* Given declspecs and a declarator,
9514    determine the name and type of the object declared
9515    and construct a ..._DECL node for it.
9516    (In one case we can return a ..._TYPE node instead.
9517     For invalid input we sometimes return 0.)
9518
9519    DECLSPECS is a chain of tree_list nodes whose value fields
9520     are the storage classes and type specifiers.
9521
9522    DECL_CONTEXT says which syntactic context this declaration is in:
9523      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9524      FUNCDEF for a function definition.  Like NORMAL but a few different
9525       error messages in each case.  Return value may be zero meaning
9526       this definition is too screwy to try to parse.
9527      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
9528       handle member functions (which have FIELD context).
9529       Return value may be zero meaning this definition is too screwy to
9530       try to parse.
9531      PARM for a parameter declaration (either within a function prototype
9532       or before a function body).  Make a PARM_DECL, or return void_type_node.
9533      CATCHPARM for a parameter declaration before a catch clause.
9534      TYPENAME if for a typename (in a cast or sizeof).
9535       Don't make a DECL node; just return the ..._TYPE node.
9536      FIELD for a struct or union field; make a FIELD_DECL.
9537      BITFIELD for a field with specified width.
9538    INITIALIZED is 1 if the decl has an initializer.
9539
9540    ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
9541    normal attributes in TREE_PURPOSE, or NULL_TREE.
9542
9543    In the TYPENAME case, DECLARATOR is really an abstract declarator.
9544    It may also be so in the PARM case, for a prototype where the
9545    argument type is specified but not the name.
9546
9547    This function is where the complicated C meanings of `static'
9548    and `extern' are interpreted.
9549
9550    For C++, if there is any monkey business to do, the function which
9551    calls this one must do it, i.e., prepending instance variables,
9552    renaming overloaded function names, etc.
9553
9554    Note that for this C++, it is an error to define a method within a class
9555    which does not belong to that class.
9556
9557    Except in the case where SCOPE_REFs are implicitly known (such as
9558    methods within a class being redundantly qualified),
9559    declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9560    (class_name::decl_name).  The caller must also deal with this.
9561
9562    If a constructor or destructor is seen, and the context is FIELD,
9563    then the type gains the attribute TREE_HAS_x.  If such a declaration
9564    is erroneous, NULL_TREE is returned.
9565
9566    QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
9567    function, these are the qualifiers to give to the `this' pointer. We
9568    apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9569
9570    May return void_type_node if the declarator turned out to be a friend.
9571    See grokfield for details.  */
9572
9573 tree
9574 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9575      tree declspecs;
9576      tree declarator;
9577      enum decl_context decl_context;
9578      int initialized;
9579      tree attrlist;
9580 {
9581   RID_BIT_TYPE specbits;
9582   int nclasses = 0;
9583   tree spec;
9584   tree type = NULL_TREE;
9585   int longlong = 0;
9586   int constp;
9587   int restrictp;
9588   int volatilep;
9589   int type_quals;
9590   int virtualp, explicitp, friendp, inlinep, staticp;
9591   int explicit_int = 0;
9592   int explicit_char = 0;
9593   int defaulted_int = 0;
9594   tree typedef_decl = NULL_TREE;
9595   const char *name;
9596   tree typedef_type = NULL_TREE;
9597   int funcdef_flag = 0;
9598   enum tree_code innermost_code = ERROR_MARK;
9599   int bitfield = 0;
9600 #if 0
9601   /* See the code below that used this.  */
9602   tree decl_machine_attr = NULL_TREE;
9603 #endif
9604   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9605      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9606   tree init = NULL_TREE;
9607
9608   /* Keep track of what sort of function is being processed
9609      so that we can warn about default return values, or explicit
9610      return values which do not match prescribed defaults.  */
9611   special_function_kind sfk = sfk_none;
9612
9613   tree dname = NULL_TREE;
9614   tree ctype = current_class_type;
9615   tree ctor_return_type = NULL_TREE;
9616   enum overload_flags flags = NO_SPECIAL;
9617   tree quals = NULL_TREE;
9618   tree raises = NULL_TREE;
9619   int template_count = 0;
9620   tree in_namespace = NULL_TREE;
9621   tree inner_attrs;
9622   int ignore_attrs;
9623
9624   RIDBIT_RESET_ALL (specbits);
9625   if (decl_context == FUNCDEF)
9626     funcdef_flag = 1, decl_context = NORMAL;
9627   else if (decl_context == MEMFUNCDEF)
9628     funcdef_flag = -1, decl_context = FIELD;
9629   else if (decl_context == BITFIELD)
9630     bitfield = 1, decl_context = FIELD;
9631
9632   /* Look inside a declarator for the name being declared
9633      and get it as a string, for an error message.  */
9634   {
9635     tree *next = &declarator;
9636     register tree decl;
9637     name = NULL;
9638
9639     while (next && *next)
9640       {
9641         decl = *next;
9642         switch (TREE_CODE (decl))
9643           {
9644           case TREE_LIST:
9645             /* For attributes.  */
9646             next = &TREE_VALUE (decl);
9647             break;
9648
9649           case COND_EXPR:
9650             ctype = NULL_TREE;
9651             next = &TREE_OPERAND (decl, 0);
9652             break;
9653
9654           case BIT_NOT_EXPR:    /* For C++ destructors!  */
9655             {
9656               tree name = TREE_OPERAND (decl, 0);
9657               tree rename = NULL_TREE;
9658
9659               my_friendly_assert (flags == NO_SPECIAL, 152);
9660               flags = DTOR_FLAG;
9661               sfk = sfk_destructor;
9662               if (TREE_CODE (name) == TYPE_DECL)
9663                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9664               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9665               if (ctype == NULL_TREE)
9666                 {
9667                   if (current_class_type == NULL_TREE)
9668                     {
9669                       error ("destructors must be member functions");
9670                       flags = NO_SPECIAL;
9671                     }
9672                   else
9673                     {
9674                       tree t = constructor_name (current_class_name);
9675                       if (t != name)
9676                         rename = t;
9677                     }
9678                 }
9679               else
9680                 {
9681                   tree t = constructor_name (ctype);
9682                   if (t != name)
9683                     rename = t;
9684                 }
9685
9686               if (rename)
9687                 {
9688                   cp_error ("destructor `%T' must match class name `%T'",
9689                             name, rename);
9690                   TREE_OPERAND (decl, 0) = rename;
9691                 }
9692               next = &name;
9693             }
9694             break;
9695
9696           case ADDR_EXPR:       /* C++ reference declaration */
9697             /* Fall through. */
9698           case ARRAY_REF:
9699           case INDIRECT_REF:
9700             ctype = NULL_TREE;
9701             innermost_code = TREE_CODE (decl);
9702             next = &TREE_OPERAND (decl, 0);
9703             break;
9704
9705           case CALL_EXPR:
9706             if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
9707               {
9708                 /* This is actually a variable declaration using
9709                    constructor syntax.  We need to call start_decl and
9710                    cp_finish_decl so we can get the variable
9711                    initialized...  */
9712
9713                 tree attributes, prefix_attributes;
9714
9715                 *next = TREE_OPERAND (decl, 0);
9716                 init = CALL_DECLARATOR_PARMS (decl);
9717
9718                 if (attrlist)
9719                   {
9720                     attributes = TREE_PURPOSE (attrlist);
9721                     prefix_attributes = TREE_VALUE (attrlist);
9722                   }
9723                 else
9724                   {
9725                     attributes = NULL_TREE;
9726                     prefix_attributes = NULL_TREE;
9727                   }
9728
9729                 decl = start_decl (declarator, declspecs, 1,
9730                                    attributes, prefix_attributes);
9731                 decl_type_access_control (decl);
9732                 if (decl)
9733                   {
9734                     /* Look for __unused__ attribute */
9735                     if (TREE_USED (TREE_TYPE (decl)))
9736                       TREE_USED (decl) = 1;
9737                     finish_decl (decl, init, NULL_TREE);
9738                   }
9739                 else
9740                   cp_error ("invalid declarator");
9741                 return 0;
9742               }
9743             innermost_code = TREE_CODE (decl);
9744             if (decl_context == FIELD && ctype == NULL_TREE)
9745               ctype = current_class_type;
9746             if (ctype
9747                 && TREE_OPERAND (decl, 0)
9748                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9749                     && ((DECL_NAME (TREE_OPERAND (decl, 0))
9750                          == constructor_name_full (ctype))
9751                         || (DECL_NAME (TREE_OPERAND (decl, 0))
9752                             == constructor_name (ctype)))))
9753               TREE_OPERAND (decl, 0) = constructor_name (ctype);
9754             next = &TREE_OPERAND (decl, 0);
9755             decl = *next;
9756             if (ctype != NULL_TREE
9757                 && decl != NULL_TREE && flags != DTOR_FLAG
9758                 && decl == constructor_name (ctype))
9759               {
9760                 sfk = sfk_constructor;
9761                 ctor_return_type = ctype;
9762               }
9763             ctype = NULL_TREE;
9764             break;
9765
9766           case TEMPLATE_ID_EXPR:
9767               {
9768                 tree fns = TREE_OPERAND (decl, 0);
9769
9770                 if (TREE_CODE (fns) == LOOKUP_EXPR)
9771                   fns = TREE_OPERAND (fns, 0);
9772
9773                 dname = fns;
9774                 if (TREE_CODE (dname) == COMPONENT_REF)
9775                   dname = TREE_OPERAND (dname, 1);
9776                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9777                   {
9778                     my_friendly_assert (is_overloaded_fn (dname),
9779                                         19990331);
9780                     dname = DECL_NAME (get_first_fn (dname));
9781                   }
9782               }
9783           /* Fall through. */
9784
9785           case IDENTIFIER_NODE:
9786             if (TREE_CODE (decl) == IDENTIFIER_NODE)
9787               dname = decl;
9788
9789             next = 0;
9790
9791             if (is_rid (dname))
9792               {
9793                 cp_error ("declarator-id missing; using reserved word `%D'",
9794                           dname);
9795                 name = IDENTIFIER_POINTER (dname);
9796               }
9797             else if (!IDENTIFIER_TYPENAME_P (dname))
9798               name = IDENTIFIER_POINTER (dname);
9799             else
9800               {
9801                 my_friendly_assert (flags == NO_SPECIAL, 154);
9802                 flags = TYPENAME_FLAG;
9803                 ctor_return_type = TREE_TYPE (dname);
9804                 sfk = sfk_conversion;
9805                 if (IDENTIFIER_GLOBAL_VALUE (dname)
9806                     && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (dname))
9807                         == TYPE_DECL))
9808                   name = IDENTIFIER_POINTER (dname);
9809                 else
9810                   name = "<invalid operator>";
9811               }
9812             break;
9813
9814             /* C++ extension */
9815           case SCOPE_REF:
9816             {
9817               /* Perform error checking, and decide on a ctype.  */
9818               tree cname = TREE_OPERAND (decl, 0);
9819               if (cname == NULL_TREE)
9820                 ctype = NULL_TREE;
9821               else if (TREE_CODE (cname) == NAMESPACE_DECL)
9822                 {
9823                   ctype = NULL_TREE;
9824                   in_namespace = TREE_OPERAND (decl, 0);
9825                   TREE_OPERAND (decl, 0) = NULL_TREE;
9826                 }
9827               else if (! is_aggr_type (cname, 1))
9828                 TREE_OPERAND (decl, 0) = NULL_TREE;
9829               /* Must test TREE_OPERAND (decl, 1), in case user gives
9830                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
9831               else if (TREE_OPERAND (decl, 1)
9832                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9833                 ctype = cname;
9834               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9835                        || TREE_CODE (cname) == TEMPLATE_TEMPLATE_PARM)
9836                 {
9837                   cp_error ("`%T::%D' is not a valid declarator", cname,
9838                             TREE_OPERAND (decl, 1));
9839                   cp_error ("  perhaps you want `typename %T::%D' to make it a type",
9840                             cname, TREE_OPERAND (decl, 1));
9841                   return void_type_node;
9842                 }
9843               else if (ctype == NULL_TREE)
9844                 ctype = cname;
9845               else if (TREE_COMPLEXITY (decl) == current_class_depth)
9846                 TREE_OPERAND (decl, 0) = ctype;
9847               else
9848                 {
9849                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9850                     {
9851                       cp_error ("type `%T' is not derived from type `%T'",
9852                                 cname, ctype);
9853                       TREE_OPERAND (decl, 0) = NULL_TREE;
9854                     }
9855                   else
9856                     ctype = cname;
9857                 }
9858
9859               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
9860                   && ((DECL_NAME (TREE_OPERAND (decl, 1))
9861                        == constructor_name_full (ctype))
9862                       || (DECL_NAME (TREE_OPERAND (decl, 1))
9863                           == constructor_name (ctype))))
9864                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
9865               next = &TREE_OPERAND (decl, 1);
9866               decl = *next;
9867               if (ctype)
9868                 {
9869                   if (TREE_CODE (decl) == IDENTIFIER_NODE
9870                       && constructor_name (ctype) == decl)
9871                     {
9872                       sfk = sfk_constructor;
9873                       ctor_return_type = ctype;
9874                     }
9875                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
9876                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
9877                            && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
9878                                || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
9879                     {
9880                       sfk = sfk_destructor;
9881                       ctor_return_type = ctype;
9882                       flags = DTOR_FLAG;
9883                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
9884                       next = &TREE_OPERAND (decl, 0);
9885                     }
9886                 }
9887             }
9888             break;
9889
9890           case ERROR_MARK:
9891             next = 0;
9892             break;
9893
9894           case TYPE_DECL:
9895             /* Parse error puts this typespec where
9896                a declarator should go.  */
9897             cp_error ("`%T' specified as declarator-id", DECL_NAME (decl));
9898             if (TREE_TYPE (decl) == current_class_type)
9899               cp_error ("  perhaps you want `%T' for a constructor",
9900                         current_class_name);
9901             dname = DECL_NAME (decl);
9902             name = IDENTIFIER_POINTER (dname);
9903
9904             /* Avoid giving two errors for this.  */
9905             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
9906
9907             declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
9908             *next = dname;
9909             next = 0;
9910             break;
9911
9912           default:
9913             cp_compiler_error ("`%D' as declarator", decl);
9914             return 0; /* We used to do a 155 abort here.  */
9915           }
9916       }
9917   }
9918
9919   /* A function definition's declarator must have the form of
9920      a function declarator.  */
9921
9922   if (funcdef_flag && innermost_code != CALL_EXPR)
9923     return 0;
9924
9925   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
9926       && innermost_code != CALL_EXPR
9927       && ! (ctype && declspecs == NULL_TREE))
9928     {
9929       cp_error ("declaration of `%D' as non-function", dname);
9930       return void_type_node;
9931     }
9932
9933   /* Anything declared one level down from the top level
9934      must be one of the parameters of a function
9935      (because the body is at least two levels down).  */
9936
9937   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9938      by not allowing C++ class definitions to specify their parameters
9939      with xdecls (must be spec.d in the parmlist).
9940
9941      Since we now wait to push a class scope until we are sure that
9942      we are in a legitimate method context, we must set oldcname
9943      explicitly (since current_class_name is not yet alive).
9944
9945      We also want to avoid calling this a PARM if it is in a namespace.  */
9946
9947   if (decl_context == NORMAL && !toplevel_bindings_p ())
9948     {
9949       struct binding_level *b = current_binding_level;
9950       current_binding_level = b->level_chain;
9951       if (current_binding_level != 0 && toplevel_bindings_p ())
9952         decl_context = PARM;
9953       current_binding_level = b;
9954     }
9955
9956   if (name == NULL)
9957     name = decl_context == PARM ? "parameter" : "type name";
9958
9959   /* Look through the decl specs and record which ones appear.
9960      Some typespecs are defined as built-in typenames.
9961      Others, the ones that are modifiers of other types,
9962      are represented by bits in SPECBITS: set the bits for
9963      the modifiers that appear.  Storage class keywords are also in SPECBITS.
9964
9965      If there is a typedef name or a type, store the type in TYPE.
9966      This includes builtin typedefs such as `int'.
9967
9968      Set EXPLICIT_INT if the type is `int' or `char' and did not
9969      come from a user typedef.
9970
9971      Set LONGLONG if `long' is mentioned twice.
9972
9973      For C++, constructors and destructors have their own fast treatment.  */
9974
9975   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
9976     {
9977       register int i;
9978       register tree id;
9979
9980       /* Certain parse errors slip through.  For example,
9981          `int class;' is not caught by the parser. Try
9982          weakly to recover here.  */
9983       if (TREE_CODE (spec) != TREE_LIST)
9984         return 0;
9985
9986       id = TREE_VALUE (spec);
9987
9988       if (TREE_CODE (id) == IDENTIFIER_NODE)
9989         {
9990           if (id == ridpointers[(int) RID_INT]
9991               || id == ridpointers[(int) RID_CHAR]
9992               || id == ridpointers[(int) RID_BOOL]
9993               || id == ridpointers[(int) RID_WCHAR])
9994             {
9995               if (type)
9996                 {
9997                   if (id == ridpointers[(int) RID_BOOL])
9998                     error ("`bool' is now a keyword");
9999                   else
10000                     cp_error ("extraneous `%T' ignored", id);
10001                 }
10002               else
10003                 {
10004                   if (id == ridpointers[(int) RID_INT])
10005                     explicit_int = 1;
10006                   else if (id == ridpointers[(int) RID_CHAR])
10007                     explicit_char = 1;
10008                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
10009                 }
10010               goto found;
10011             }
10012           /* C++ aggregate types.  */
10013           if (IDENTIFIER_HAS_TYPE_VALUE (id))
10014             {
10015               if (type)
10016                 cp_error ("multiple declarations `%T' and `%T'", type, id);
10017               else
10018                 type = IDENTIFIER_TYPE_VALUE (id);
10019               goto found;
10020             }
10021
10022           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
10023             {
10024               if (ridpointers[i] == id)
10025                 {
10026                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
10027                     {
10028                       if (pedantic && ! in_system_header && warn_long_long)
10029                         pedwarn ("ISO C++ does not support `long long'");
10030                       if (longlong)
10031                         error ("`long long long' is too long for GCC");
10032                       else
10033                         longlong = 1;
10034                     }
10035                   else if (RIDBIT_SETP (i, specbits))
10036                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
10037                   RIDBIT_SET (i, specbits);
10038                   goto found;
10039                 }
10040             }
10041         }
10042       /* C++ aggregate types.  */
10043       else if (TREE_CODE (id) == TYPE_DECL)
10044         {
10045           if (type)
10046             cp_error ("multiple declarations `%T' and `%T'", type,
10047                       TREE_TYPE (id));
10048           else
10049             {
10050               type = TREE_TYPE (id);
10051               TREE_VALUE (spec) = type;
10052             }
10053           goto found;
10054         }
10055       if (type)
10056         error ("two or more data types in declaration of `%s'", name);
10057       else if (TREE_CODE (id) == IDENTIFIER_NODE)
10058         {
10059           register tree t = lookup_name (id, 1);
10060           if (!t || TREE_CODE (t) != TYPE_DECL)
10061             error ("`%s' fails to be a typedef or built in type",
10062                    IDENTIFIER_POINTER (id));
10063           else
10064             {
10065               type = TREE_TYPE (t);
10066 #if 0
10067               /* See the code below that used this.  */
10068               decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
10069 #endif
10070               typedef_decl = t;
10071             }
10072         }
10073       else if (id != error_mark_node)
10074         /* Can't change CLASS nodes into RECORD nodes here!  */
10075         type = id;
10076
10077     found: ;
10078     }
10079
10080   typedef_type = type;
10081
10082   /* No type at all: default to `int', and set DEFAULTED_INT
10083      because it was not a user-defined typedef.  */
10084
10085   if (type == NULL_TREE
10086       && (RIDBIT_SETP (RID_SIGNED, specbits)
10087           || RIDBIT_SETP (RID_UNSIGNED, specbits)
10088           || RIDBIT_SETP (RID_LONG, specbits)
10089           || RIDBIT_SETP (RID_SHORT, specbits)))
10090     {
10091       /* These imply 'int'.  */
10092       type = integer_type_node;
10093       defaulted_int = 1;
10094     }
10095
10096   if (sfk != sfk_none)
10097     type = check_special_function_return_type (sfk, type,
10098                                                ctor_return_type,
10099                                                ctor_return_type);
10100   else if (type == NULL_TREE)
10101     {
10102       int is_main;
10103
10104       explicit_int = -1;
10105
10106           /* We handle `main' specially here, because 'main () { }' is so
10107              common.  With no options, it is allowed.  With -Wreturn-type,
10108              it is a warning.  It is only an error with -pedantic-errors.  */
10109       is_main = (funcdef_flag
10110                  && MAIN_NAME_P (dname)
10111                  && ctype == NULL_TREE
10112                  && in_namespace == NULL_TREE
10113                  && current_namespace == global_namespace);
10114
10115       if (in_system_header || flag_ms_extensions)
10116         /* Allow it, sigh.  */;
10117       else if (pedantic || ! is_main)
10118         cp_pedwarn ("ISO C++ forbids declaration of `%s' with no type",
10119                     name);
10120       else if (warn_return_type)
10121         cp_warning ("ISO C++ forbids declaration of `%s' with no type",
10122                     name);
10123
10124       type = integer_type_node;
10125     }
10126
10127   ctype = NULL_TREE;
10128
10129   /* Now process the modifiers that were specified
10130      and check for invalid combinations.  */
10131
10132   /* Long double is a special combination.  */
10133
10134   if (RIDBIT_SETP (RID_LONG, specbits)
10135       && TYPE_MAIN_VARIANT (type) == double_type_node)
10136     {
10137       RIDBIT_RESET (RID_LONG, specbits);
10138       type = build_qualified_type (long_double_type_node,
10139                                    CP_TYPE_QUALS (type));
10140     }
10141
10142   /* Check all other uses of type modifiers.  */
10143
10144   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10145       || RIDBIT_SETP (RID_SIGNED, specbits)
10146       || RIDBIT_SETP (RID_LONG, specbits)
10147       || RIDBIT_SETP (RID_SHORT, specbits))
10148     {
10149       int ok = 0;
10150
10151       if (TREE_CODE (type) == REAL_TYPE)
10152         error ("short, signed or unsigned invalid for `%s'", name);
10153       else if (TREE_CODE (type) != INTEGER_TYPE)
10154         error ("long, short, signed or unsigned invalid for `%s'", name);
10155       else if (RIDBIT_SETP (RID_LONG, specbits)
10156                && RIDBIT_SETP (RID_SHORT, specbits))
10157         error ("long and short specified together for `%s'", name);
10158       else if ((RIDBIT_SETP (RID_LONG, specbits)
10159                 || RIDBIT_SETP (RID_SHORT, specbits))
10160                && explicit_char)
10161         error ("long or short specified with char for `%s'", name);
10162       else if ((RIDBIT_SETP (RID_LONG, specbits)
10163                 || RIDBIT_SETP (RID_SHORT, specbits))
10164                && TREE_CODE (type) == REAL_TYPE)
10165         error ("long or short specified with floating type for `%s'", name);
10166       else if (RIDBIT_SETP (RID_SIGNED, specbits)
10167                && RIDBIT_SETP (RID_UNSIGNED, specbits))
10168         error ("signed and unsigned given together for `%s'", name);
10169       else
10170         {
10171           ok = 1;
10172           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
10173             {
10174               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10175                        name);
10176               if (flag_pedantic_errors)
10177                 ok = 0;
10178             }
10179         }
10180
10181       /* Discard the type modifiers if they are invalid.  */
10182       if (! ok)
10183         {
10184           RIDBIT_RESET (RID_UNSIGNED, specbits);
10185           RIDBIT_RESET (RID_SIGNED, specbits);
10186           RIDBIT_RESET (RID_LONG, specbits);
10187           RIDBIT_RESET (RID_SHORT, specbits);
10188           longlong = 0;
10189         }
10190     }
10191
10192   if (RIDBIT_SETP (RID_COMPLEX, specbits)
10193       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
10194     {
10195       error ("complex invalid for `%s'", name);
10196       RIDBIT_RESET (RID_COMPLEX, specbits);
10197     }
10198
10199   /* Decide whether an integer type is signed or not.
10200      Optionally treat bitfields as signed by default.  */
10201   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10202       /* [class.bit]
10203
10204          It is implementation-defined whether a plain (neither
10205          explicitly signed or unsigned) char, short, int, or long
10206          bit-field is signed or unsigned.
10207
10208          Naturally, we extend this to long long as well.  Note that
10209          this does not include wchar_t.  */
10210       || (bitfield && !flag_signed_bitfields
10211           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
10212           /* A typedef for plain `int' without `signed' can be
10213              controlled just like plain `int', but a typedef for
10214              `signed int' cannot be so controlled.  */
10215           && !(typedef_decl
10216                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
10217           && (TREE_CODE (type) == INTEGER_TYPE
10218               || TREE_CODE (type) == CHAR_TYPE)
10219           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
10220     {
10221       if (longlong)
10222         type = long_long_unsigned_type_node;
10223       else if (RIDBIT_SETP (RID_LONG, specbits))
10224         type = long_unsigned_type_node;
10225       else if (RIDBIT_SETP (RID_SHORT, specbits))
10226         type = short_unsigned_type_node;
10227       else if (type == char_type_node)
10228         type = unsigned_char_type_node;
10229       else if (typedef_decl)
10230         type = unsigned_type (type);
10231       else
10232         type = unsigned_type_node;
10233     }
10234   else if (RIDBIT_SETP (RID_SIGNED, specbits)
10235            && type == char_type_node)
10236     type = signed_char_type_node;
10237   else if (longlong)
10238     type = long_long_integer_type_node;
10239   else if (RIDBIT_SETP (RID_LONG, specbits))
10240     type = long_integer_type_node;
10241   else if (RIDBIT_SETP (RID_SHORT, specbits))
10242     type = short_integer_type_node;
10243
10244   if (RIDBIT_SETP (RID_COMPLEX, specbits))
10245     {
10246       /* If we just have "complex", it is equivalent to
10247          "complex double", but if any modifiers at all are specified it is
10248          the complex form of TYPE.  E.g, "complex short" is
10249          "complex short int".  */
10250
10251       if (defaulted_int && ! longlong
10252           && ! (RIDBIT_SETP (RID_LONG, specbits)
10253                 || RIDBIT_SETP (RID_SHORT, specbits)
10254                 || RIDBIT_SETP (RID_SIGNED, specbits)
10255                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
10256         type = complex_double_type_node;
10257       else if (type == integer_type_node)
10258         type = complex_integer_type_node;
10259       else if (type == float_type_node)
10260         type = complex_float_type_node;
10261       else if (type == double_type_node)
10262         type = complex_double_type_node;
10263       else if (type == long_double_type_node)
10264         type = complex_long_double_type_node;
10265       else
10266         type = build_complex_type (type);
10267     }
10268
10269   if (sfk == sfk_conversion
10270       && (RIDBIT_SETP (RID_CONST, specbits)
10271           || RIDBIT_SETP (RID_VOLATILE, specbits)
10272           || RIDBIT_SETP (RID_RESTRICT, specbits)))
10273     cp_error ("qualifiers are not allowed on declaration of `operator %T'",
10274               ctor_return_type);
10275
10276   /* Set CONSTP if this declaration is `const', whether by
10277      explicit specification or via a typedef.
10278      Likewise for VOLATILEP.  */
10279
10280   constp = !! RIDBIT_SETP (RID_CONST, specbits) + CP_TYPE_CONST_P (type);
10281   restrictp =
10282     !! RIDBIT_SETP (RID_RESTRICT, specbits) + CP_TYPE_RESTRICT_P (type);
10283   volatilep =
10284     !! RIDBIT_SETP (RID_VOLATILE, specbits) + CP_TYPE_VOLATILE_P (type);
10285   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10286                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10287                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10288   type = cp_build_qualified_type (type, type_quals);
10289   staticp = 0;
10290   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
10291   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
10292   RIDBIT_RESET (RID_VIRTUAL, specbits);
10293   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
10294   RIDBIT_RESET (RID_EXPLICIT, specbits);
10295
10296   if (RIDBIT_SETP (RID_STATIC, specbits))
10297     staticp = 1 + (decl_context == FIELD);
10298
10299   if (virtualp && staticp == 2)
10300     {
10301       cp_error ("member `%D' cannot be declared both virtual and static",
10302                 dname);
10303       staticp = 0;
10304     }
10305   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
10306   RIDBIT_RESET (RID_FRIEND, specbits);
10307
10308   /* Warn if two storage classes are given. Default to `auto'.  */
10309
10310   if (RIDBIT_ANY_SET (specbits))
10311     {
10312       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
10313       if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
10314       if (decl_context == PARM && nclasses > 0)
10315         error ("storage class specifiers invalid in parameter declarations");
10316       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10317         {
10318           if (decl_context == PARM)
10319             error ("typedef declaration invalid in parameter declaration");
10320           nclasses++;
10321         }
10322       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
10323       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
10324     }
10325
10326   /* Give error if `virtual' is used outside of class declaration.  */
10327   if (virtualp
10328       && (current_class_name == NULL_TREE || decl_context != FIELD))
10329     {
10330       error ("virtual outside class declaration");
10331       virtualp = 0;
10332     }
10333
10334   /* Static anonymous unions are dealt with here.  */
10335   if (staticp && decl_context == TYPENAME
10336       && TREE_CODE (declspecs) == TREE_LIST
10337       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
10338     decl_context = FIELD;
10339
10340   /* Warn about storage classes that are invalid for certain
10341      kinds of declarations (parameters, typenames, etc.).  */
10342
10343   if (nclasses > 1)
10344     error ("multiple storage classes in declaration of `%s'", name);
10345   else if (decl_context != NORMAL && nclasses > 0)
10346     {
10347       if ((decl_context == PARM || decl_context == CATCHPARM)
10348           && (RIDBIT_SETP (RID_REGISTER, specbits)
10349               || RIDBIT_SETP (RID_AUTO, specbits)))
10350         ;
10351       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10352         ;
10353       else if (decl_context == FIELD
10354                /* C++ allows static class elements  */
10355                && RIDBIT_SETP (RID_STATIC, specbits))
10356         /* C++ also allows inlines and signed and unsigned elements,
10357            but in those cases we don't come in here.  */
10358         ;
10359       else
10360         {
10361           if (decl_context == FIELD)
10362             {
10363               tree tmp = NULL_TREE;
10364               register int op = 0;
10365
10366               if (declarator)
10367                 {
10368                   /* Avoid trying to get an operand off an identifier node.  */
10369                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10370                     tmp = declarator;
10371                   else
10372                     tmp = TREE_OPERAND (declarator, 0);
10373                   op = IDENTIFIER_OPNAME_P (tmp);
10374                   if (IDENTIFIER_TYPENAME_P (tmp))
10375                     {
10376                       if (IDENTIFIER_GLOBAL_VALUE (tmp)
10377                           && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (tmp))
10378                               == TYPE_DECL))
10379                         name = IDENTIFIER_POINTER (tmp);
10380                       else
10381                         name = "<invalid operator>";
10382                     }
10383                 }
10384               error ("storage class specified for %s `%s'",
10385                      op ? "member operator" : "field",
10386                      name);
10387             }
10388           else
10389             {
10390               if (decl_context == PARM || decl_context == CATCHPARM)
10391                 error ("storage class specified for parameter `%s'", name);
10392               else
10393                 error ("storage class specified for typename");
10394             }
10395           RIDBIT_RESET (RID_REGISTER, specbits);
10396           RIDBIT_RESET (RID_AUTO, specbits);
10397           RIDBIT_RESET (RID_EXTERN, specbits);
10398         }
10399     }
10400   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10401     {
10402       if (toplevel_bindings_p ())
10403         {
10404           /* It's common practice (and completely valid) to have a const
10405              be initialized and declared extern.  */
10406           if (!(type_quals & TYPE_QUAL_CONST))
10407             warning ("`%s' initialized and declared `extern'", name);
10408         }
10409       else
10410         error ("`%s' has both `extern' and initializer", name);
10411     }
10412   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10413            && ! toplevel_bindings_p ())
10414     error ("nested function `%s' declared `extern'", name);
10415   else if (toplevel_bindings_p ())
10416     {
10417       if (RIDBIT_SETP (RID_AUTO, specbits))
10418         error ("top-level declaration of `%s' specifies `auto'", name);
10419     }
10420
10421   if (nclasses > 0 && friendp)
10422     error ("storage class specifiers invalid in friend function declarations");
10423
10424   /* Now figure out the structure of the declarator proper.
10425      Descend through it, creating more complex types, until we reach
10426      the declared identifier (or NULL_TREE, in an absolute declarator).  */
10427
10428   inner_attrs = NULL_TREE;
10429   ignore_attrs = 0;
10430
10431   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10432          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10433     {
10434       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10435          an INDIRECT_REF (for *...),
10436          a CALL_EXPR (for ...(...)),
10437          an identifier (for the name being declared)
10438          or a null pointer (for the place in an absolute declarator
10439          where the name was omitted).
10440          For the last two cases, we have just exited the loop.
10441
10442          For C++ it could also be
10443          a SCOPE_REF (for class :: ...).  In this case, we have converted
10444          sensible names to types, and those are the values we use to
10445          qualify the member name.
10446          an ADDR_EXPR (for &...),
10447          a BIT_NOT_EXPR (for destructors)
10448
10449          At this point, TYPE is the type of elements of an array,
10450          or for a function to return, or for a pointer to point to.
10451          After this sequence of ifs, TYPE is the type of the
10452          array or function or pointer, and DECLARATOR has had its
10453          outermost layer removed.  */
10454
10455       if (type == error_mark_node)
10456         {
10457           if (TREE_CODE (declarator) == SCOPE_REF)
10458             declarator = TREE_OPERAND (declarator, 1);
10459           else
10460             declarator = TREE_OPERAND (declarator, 0);
10461           continue;
10462         }
10463       if (quals != NULL_TREE
10464           && (declarator == NULL_TREE
10465               || TREE_CODE (declarator) != SCOPE_REF))
10466         {
10467           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10468             ctype = TYPE_METHOD_BASETYPE (type);
10469           if (ctype != NULL_TREE)
10470             {
10471               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10472               grok_method_quals (ctype, dummy, quals);
10473               type = TREE_TYPE (dummy);
10474               ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
10475               quals = NULL_TREE;
10476             }
10477         }
10478
10479       /* See the comment for the TREE_LIST case, below.  */
10480       if (ignore_attrs)
10481         ignore_attrs = 0;
10482       else if (inner_attrs)
10483         {
10484           decl_attributes (type, inner_attrs, NULL_TREE);
10485           inner_attrs = NULL_TREE;
10486         }
10487
10488       switch (TREE_CODE (declarator))
10489         {
10490         case TREE_LIST:
10491           {
10492             /* We encode a declarator with embedded attributes using
10493                a TREE_LIST.  The attributes apply to the declarator
10494                directly inside them, so we have to skip an iteration
10495                before applying them to the type.  If the declarator just
10496                inside is the declarator-id, we apply the attrs to the
10497                decl itself.  */
10498             inner_attrs = TREE_PURPOSE (declarator);
10499             ignore_attrs = 1;
10500             declarator = TREE_VALUE (declarator);
10501           }
10502           break;
10503
10504         case ARRAY_REF:
10505           {
10506             register tree size;
10507
10508             size = TREE_OPERAND (declarator, 1);
10509
10510             /* VC++ spells a zero-sized array with [].  */
10511             if (size == NULL_TREE && decl_context == FIELD && ! staticp
10512                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10513               size = integer_zero_node;
10514
10515             declarator = TREE_OPERAND (declarator, 0);
10516
10517             type = create_array_type_for_decl (dname, type, size);
10518
10519             /* VLAs never work as fields. */
10520             if (decl_context == FIELD && !processing_template_decl
10521                 && TREE_CODE (type) == ARRAY_TYPE
10522                 && TYPE_DOMAIN (type) != NULL_TREE
10523                 && !TREE_CONSTANT (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
10524               {
10525                 cp_error ("size of member `%D' is not constant", dname);
10526                 /* Proceed with arbitrary constant size, so that offset
10527                    computations don't get confused. */
10528                 type = create_array_type_for_decl (dname, TREE_TYPE (type),
10529                                                    integer_one_node);
10530               }
10531
10532             ctype = NULL_TREE;
10533           }
10534           break;
10535
10536         case CALL_EXPR:
10537           {
10538             tree arg_types;
10539             int funcdecl_p;
10540             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10541             tree inner_decl = TREE_OPERAND (declarator, 0);
10542
10543             /* Declaring a function type.
10544                Make sure we have a valid type for the function to return.  */
10545
10546             /* We now know that the TYPE_QUALS don't apply to the
10547                decl, but to its return type.  */
10548             type_quals = TYPE_UNQUALIFIED;
10549
10550             /* Warn about some types functions can't return.  */
10551
10552             if (TREE_CODE (type) == FUNCTION_TYPE)
10553               {
10554                 error ("`%s' declared as function returning a function", name);
10555                 type = integer_type_node;
10556               }
10557             if (TREE_CODE (type) == ARRAY_TYPE)
10558               {
10559                 error ("`%s' declared as function returning an array", name);
10560                 type = integer_type_node;
10561               }
10562
10563             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10564               inner_decl = TREE_OPERAND (inner_decl, 1);
10565
10566             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10567               inner_decl = dname;
10568
10569             /* Pick up type qualifiers which should be applied to `this'.  */
10570             quals = CALL_DECLARATOR_QUALS (declarator);
10571
10572             /* Pick up the exception specifications.  */
10573             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10574
10575             /* Say it's a definition only for the CALL_EXPR
10576                closest to the identifier.  */
10577             funcdecl_p
10578               = inner_decl
10579               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10580                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10581                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10582
10583             if (ctype == NULL_TREE
10584                 && decl_context == FIELD
10585                 && funcdecl_p
10586                 && (friendp == 0 || dname == current_class_name))
10587               ctype = current_class_type;
10588
10589             if (ctype && sfk == sfk_conversion)
10590               TYPE_HAS_CONVERSION (ctype) = 1;
10591             if (ctype && constructor_name (ctype) == dname)
10592               {
10593                 /* We are within a class's scope. If our declarator name
10594                    is the same as the class name, and we are defining
10595                    a function, then it is a constructor/destructor, and
10596                    therefore returns a void type.  */
10597
10598                 if (flags == DTOR_FLAG)
10599                   {
10600                     /* ISO C++ 12.4/2.  A destructor may not be
10601                        declared const or volatile.  A destructor may
10602                        not be static.  */
10603                     if (staticp == 2)
10604                       error ("destructor cannot be static member function");
10605                     if (quals)
10606                       {
10607                         cp_error ("destructors may not be `%s'",
10608                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10609                         quals = NULL_TREE;
10610                       }
10611                     if (decl_context == FIELD)
10612                       {
10613                         if (! member_function_or_else (ctype,
10614                                                        current_class_type,
10615                                                        flags))
10616                           return void_type_node;
10617                       }
10618                   }
10619                 else            /* It's a constructor.  */
10620                   {
10621                     if (explicitp == 1)
10622                       explicitp = 2;
10623                     /* ISO C++ 12.1.  A constructor may not be
10624                        declared const or volatile.  A constructor may
10625                        not be virtual.  A constructor may not be
10626                        static.  */
10627                     if (staticp == 2)
10628                       error ("constructor cannot be static member function");
10629                     if (virtualp)
10630                       {
10631                         pedwarn ("constructors cannot be declared virtual");
10632                         virtualp = 0;
10633                       }
10634                     if (quals)
10635                       {
10636                         cp_error ("constructors may not be `%s'",
10637                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10638                         quals = NULL_TREE;
10639                       }
10640                     {
10641                       RID_BIT_TYPE tmp_bits;
10642                       bcopy ((void*)&specbits, (void*)&tmp_bits, sizeof (RID_BIT_TYPE));
10643                       RIDBIT_RESET (RID_INLINE, tmp_bits);
10644                       RIDBIT_RESET (RID_STATIC, tmp_bits);
10645                       if (RIDBIT_ANY_SET (tmp_bits))
10646                         error ("return value type specifier for constructor ignored");
10647                     }
10648                     if (decl_context == FIELD)
10649                       {
10650                         if (! member_function_or_else (ctype,
10651                                                        current_class_type,
10652                                                        flags))
10653                           return void_type_node;
10654                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10655                         if (sfk != sfk_constructor)
10656                           return NULL_TREE;
10657                       }
10658                   }
10659                 if (decl_context == FIELD)
10660                   staticp = 0;
10661               }
10662             else if (friendp)
10663               {
10664                 if (initialized)
10665                   error ("can't initialize friend function `%s'", name);
10666                 if (virtualp)
10667                   {
10668                     /* Cannot be both friend and virtual.  */
10669                     error ("virtual functions cannot be friends");
10670                     RIDBIT_RESET (RID_FRIEND, specbits);
10671                     friendp = 0;
10672                   }
10673                 if (decl_context == NORMAL)
10674                   error ("friend declaration not in class definition");
10675                 if (current_function_decl && funcdef_flag)
10676                   cp_error ("can't define friend function `%s' in a local class definition",
10677                             name);
10678               }
10679
10680             /* Construct the function type and go to the next
10681                inner layer of declarator.  */
10682
10683             declarator = TREE_OPERAND (declarator, 0);
10684
10685             /* FIXME: This is where default args should be fully
10686                processed.  */
10687
10688             arg_types = grokparms (inner_parms, funcdecl_p ? funcdef_flag : 0);
10689
10690             if (declarator && flags == DTOR_FLAG)
10691               {
10692                 /* A destructor declared in the body of a class will
10693                    be represented as a BIT_NOT_EXPR.  But, we just
10694                    want the underlying IDENTIFIER.  */
10695                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10696                   declarator = TREE_OPERAND (declarator, 0);
10697
10698                 if (arg_types != void_list_node)
10699                   {
10700                     cp_error ("destructors may not have parameters");
10701                     arg_types = void_list_node;
10702                     last_function_parms = NULL_TREE;
10703                   }
10704               }
10705
10706             /* ANSI says that `const int foo ();'
10707                does not make the function foo const.  */
10708             type = build_function_type (type, arg_types);
10709
10710             {
10711               tree t;
10712               for (t = arg_types; t; t = TREE_CHAIN (t))
10713                 if (TREE_PURPOSE (t)
10714                     && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10715                   {
10716                     add_defarg_fn (type);
10717                     break;
10718                   }
10719             }
10720           }
10721           break;
10722
10723         case ADDR_EXPR:
10724         case INDIRECT_REF:
10725           /* Filter out pointers-to-references and references-to-references.
10726              We can get these if a TYPE_DECL is used.  */
10727
10728           if (TREE_CODE (type) == REFERENCE_TYPE)
10729             {
10730               error ("cannot declare %s to references",
10731                      TREE_CODE (declarator) == ADDR_EXPR
10732                      ? "references" : "pointers");
10733               declarator = TREE_OPERAND (declarator, 0);
10734               continue;
10735             }
10736
10737           if (TREE_CODE (type) == OFFSET_TYPE
10738               && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10739                   || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10740             {
10741               cp_error ("cannot declare pointer to `%#T' member",
10742                         TREE_TYPE (type));
10743               type = TREE_TYPE (type);
10744             }
10745
10746           /* Merge any constancy or volatility into the target type
10747              for the pointer.  */
10748
10749           /* We now know that the TYPE_QUALS don't apply to the decl,
10750              but to the target of the pointer.  */
10751           type_quals = TYPE_UNQUALIFIED;
10752
10753           if (TREE_CODE (declarator) == ADDR_EXPR)
10754             {
10755               if (TREE_CODE (type) == VOID_TYPE)
10756                 error ("invalid type: `void &'");
10757               else
10758                 type = build_reference_type (type);
10759             }
10760           else if (TREE_CODE (type) == METHOD_TYPE)
10761             type = build_ptrmemfunc_type (build_pointer_type (type));
10762           else
10763             type = build_pointer_type (type);
10764
10765           /* Process a list of type modifier keywords (such as
10766              const or volatile) that were given inside the `*' or `&'.  */
10767
10768           if (TREE_TYPE (declarator))
10769             {
10770               register tree typemodlist;
10771               int erred = 0;
10772
10773               constp = 0;
10774               volatilep = 0;
10775               restrictp = 0;
10776               for (typemodlist = TREE_TYPE (declarator); typemodlist;
10777                    typemodlist = TREE_CHAIN (typemodlist))
10778                 {
10779                   tree qualifier = TREE_VALUE (typemodlist);
10780
10781                   if (qualifier == ridpointers[(int) RID_CONST])
10782                     constp++;
10783                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
10784                     volatilep++;
10785                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
10786                     restrictp++;
10787                   else if (!erred)
10788                     {
10789                       erred = 1;
10790                       error ("invalid type modifier within pointer declarator");
10791                     }
10792                 }
10793               if (constp > 1)
10794                 pedwarn ("duplicate `const'");
10795               if (volatilep > 1)
10796                 pedwarn ("duplicate `volatile'");
10797               if (restrictp > 1)
10798                 pedwarn ("duplicate `restrict'");
10799
10800               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10801                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10802                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10803               if (TREE_CODE (declarator) == ADDR_EXPR
10804                   && (constp || volatilep))
10805                 {
10806                   if (constp)
10807                     pedwarn ("discarding `const' applied to a reference");
10808                   if (volatilep)
10809                     pedwarn ("discarding `volatile' applied to a reference");
10810                   type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
10811                 }
10812               type = cp_build_qualified_type (type, type_quals);
10813             }
10814           declarator = TREE_OPERAND (declarator, 0);
10815           ctype = NULL_TREE;
10816           break;
10817
10818         case SCOPE_REF:
10819           {
10820             /* We have converted type names to NULL_TREE if the
10821                name was bogus, or to a _TYPE node, if not.
10822
10823                The variable CTYPE holds the type we will ultimately
10824                resolve to.  The code here just needs to build
10825                up appropriate member types.  */
10826             tree sname = TREE_OPERAND (declarator, 1);
10827             tree t;
10828
10829             /* Destructors can have their visibilities changed as well.  */
10830             if (TREE_CODE (sname) == BIT_NOT_EXPR)
10831               sname = TREE_OPERAND (sname, 0);
10832
10833             if (TREE_COMPLEXITY (declarator) == 0)
10834               /* This needs to be here, in case we are called
10835                  multiple times.  */ ;
10836             else if (TREE_COMPLEXITY (declarator) == -1)
10837               /* Namespace member. */
10838               pop_decl_namespace ();
10839             else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
10840               /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10841             else if (! IS_AGGR_TYPE_CODE
10842                      (TREE_CODE (TREE_OPERAND (declarator, 0))))
10843               ;
10844             else if (TREE_COMPLEXITY (declarator) == current_class_depth)
10845               {
10846                 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10847                    that refer to ctype.  They couldn't be resolved earlier
10848                    because we hadn't pushed into the class yet.
10849                    Example: resolve 'B<T>::type' in
10850                    'B<typename B<T>::type> B<T>::f () { }'.  */
10851                 if (current_template_parms
10852                     && uses_template_parms (type)
10853                     && uses_template_parms (current_class_type))
10854                   {
10855                     tree args = current_template_args ();
10856                     type = tsubst (type, args, /*complain=*/1, NULL_TREE);
10857                   }
10858
10859                 /* This pop_nested_class corresponds to the
10860                    push_nested_class used to push into class scope for
10861                    parsing the argument list of a function decl, in
10862                    qualified_id.  */
10863                 pop_nested_class ();
10864                 TREE_COMPLEXITY (declarator) = current_class_depth;
10865               }
10866             else
10867               my_friendly_abort (16);
10868
10869             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
10870               {
10871                 /* We had a reference to a global decl, or
10872                    perhaps we were given a non-aggregate typedef,
10873                    in which case we cleared this out, and should just
10874                    keep going as though it wasn't there.  */
10875                 declarator = sname;
10876                 continue;
10877               }
10878             ctype = TREE_OPERAND (declarator, 0);
10879
10880             t = ctype;
10881             while (t != NULL_TREE && CLASS_TYPE_P (t))
10882               {
10883                 /* You're supposed to have one `template <...>'
10884                    for every template class, but you don't need one
10885                    for a full specialization.  For example:
10886
10887                      template <class T> struct S{};
10888                      template <> struct S<int> { void f(); };
10889                      void S<int>::f () {}
10890
10891                    is correct; there shouldn't be a `template <>' for
10892                    the definition of `S<int>::f'.  */
10893                 if (CLASSTYPE_TEMPLATE_INFO (t)
10894                     && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
10895                         || uses_template_parms (CLASSTYPE_TI_ARGS (t))))
10896                   template_count += 1;
10897
10898                 t = TYPE_MAIN_DECL (t);
10899                 if (DECL_LANG_SPECIFIC (t))
10900                   t = DECL_CONTEXT (t);
10901                 else
10902                   t = NULL_TREE;
10903               }
10904
10905             if (sname == NULL_TREE)
10906               goto done_scoping;
10907
10908             if (TREE_CODE (sname) == IDENTIFIER_NODE)
10909               {
10910                 /* This is the `standard' use of the scoping operator:
10911                    basetype :: member .  */
10912
10913                 if (ctype == current_class_type)
10914                   {
10915                     /* class A {
10916                          void A::f ();
10917                        };
10918
10919                        Is this ill-formed?  */
10920
10921                     if (pedantic)
10922                       cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10923                                   ctype, name);
10924                   }
10925                 else if (TREE_CODE (type) == FUNCTION_TYPE)
10926                   {
10927                     if (current_class_type == NULL_TREE
10928                         || friendp)
10929                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10930                                                       TYPE_ARG_TYPES (type));
10931                     else
10932                       {
10933                         cp_error ("cannot declare member function `%T::%s' within `%T'",
10934                                   ctype, name, current_class_type);
10935                         return void_type_node;
10936                       }
10937                   }
10938                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
10939                          || COMPLETE_TYPE_P (complete_type (ctype)))
10940                   {
10941                     /* Have to move this code elsewhere in this function.
10942                        this code is used for i.e., typedef int A::M; M *pm;
10943
10944                        It is?  How? jason 10/2/94 */
10945
10946                     if (current_class_type)
10947                       {
10948                         cp_error ("cannot declare member `%T::%s' within `%T'",
10949                                   ctype, name, current_class_type);
10950                         return void_type_node;
10951                       }
10952                     type = build_offset_type (ctype, type);
10953                   }
10954                 else if (uses_template_parms (ctype))
10955                   {
10956                     if (TREE_CODE (type) == FUNCTION_TYPE)
10957                       type
10958                         = build_cplus_method_type (ctype, TREE_TYPE (type),
10959                                                    TYPE_ARG_TYPES (type));
10960                   }
10961                 else
10962                   {
10963                     cp_error ("structure `%T' not yet defined", ctype);
10964                     return error_mark_node;
10965                   }
10966
10967                 declarator = sname;
10968               }
10969             else if (TREE_CODE (sname) == SCOPE_REF)
10970               my_friendly_abort (17);
10971             else
10972               {
10973               done_scoping:
10974                 declarator = TREE_OPERAND (declarator, 1);
10975                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
10976                   /* In this case, we will deal with it later.  */
10977                   ;
10978                 else
10979                   {
10980                     if (TREE_CODE (type) == FUNCTION_TYPE)
10981                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10982                                                       TYPE_ARG_TYPES (type));
10983                     else
10984                       type = build_offset_type (ctype, type);
10985                   }
10986               }
10987           }
10988           break;
10989
10990         case BIT_NOT_EXPR:
10991           declarator = TREE_OPERAND (declarator, 0);
10992           break;
10993
10994         case RECORD_TYPE:
10995         case UNION_TYPE:
10996         case ENUMERAL_TYPE:
10997           declarator = NULL_TREE;
10998           break;
10999
11000         case ERROR_MARK:
11001           declarator = NULL_TREE;
11002           break;
11003
11004         default:
11005           my_friendly_abort (158);
11006         }
11007     }
11008
11009   /* See the comment for the TREE_LIST case, above.  */
11010   if (inner_attrs)
11011     {
11012       if (! ignore_attrs)
11013         decl_attributes (type, inner_attrs, NULL_TREE);
11014       else if (attrlist)
11015         TREE_VALUE (attrlist) = chainon (inner_attrs, TREE_VALUE (attrlist));
11016       else
11017         attrlist = build_decl_list (NULL_TREE, inner_attrs);
11018     }
11019
11020   /* Now TYPE has the actual type.  */
11021
11022   if (explicitp == 1 || (explicitp && friendp))
11023     {
11024       /* [dcl.fct.spec] The explicit specifier shall only be used in
11025          declarations of constructors within a class definition.  */
11026       error ("only declarations of constructors can be `explicit'");
11027       explicitp = 0;
11028     }
11029
11030   if (RIDBIT_SETP (RID_MUTABLE, specbits))
11031     {
11032       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
11033         {
11034           error ("non-member `%s' cannot be declared `mutable'", name);
11035           RIDBIT_RESET (RID_MUTABLE, specbits);
11036         }
11037       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
11038         {
11039           error ("non-object member `%s' cannot be declared `mutable'", name);
11040           RIDBIT_RESET (RID_MUTABLE, specbits);
11041         }
11042       else if (TREE_CODE (type) == FUNCTION_TYPE
11043                || TREE_CODE (type) == METHOD_TYPE)
11044         {
11045           error ("function `%s' cannot be declared `mutable'", name);
11046           RIDBIT_RESET (RID_MUTABLE, specbits);
11047         }
11048       else if (staticp)
11049         {
11050           error ("static `%s' cannot be declared `mutable'", name);
11051           RIDBIT_RESET (RID_MUTABLE, specbits);
11052         }
11053       else if (type_quals & TYPE_QUAL_CONST)
11054         {
11055           error ("const `%s' cannot be declared `mutable'", name);
11056           RIDBIT_RESET (RID_MUTABLE, specbits);
11057         }
11058     }
11059
11060   if (declarator == NULL_TREE
11061       || TREE_CODE (declarator) == IDENTIFIER_NODE
11062       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
11063           && (TREE_CODE (type) == FUNCTION_TYPE
11064               || TREE_CODE (type) == METHOD_TYPE)))
11065     /* OK */;
11066   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11067     {
11068       cp_error ("template-id `%D' used as a declarator", declarator);
11069       declarator = dname;
11070     }
11071   else
11072     /* Unexpected declarator format.  */
11073     my_friendly_abort (990210);
11074
11075   /* If this is declaring a typedef name, return a TYPE_DECL.  */
11076
11077   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
11078     {
11079       tree decl;
11080
11081       /* Note that the grammar rejects storage classes
11082          in typenames, fields or parameters.  */
11083       if (current_lang_name == lang_name_java)
11084         TYPE_FOR_JAVA (type) = 1;
11085
11086       if (decl_context == FIELD)
11087         {
11088           if (declarator == constructor_name (current_class_type))
11089             cp_pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
11090                         declarator);
11091           decl = build_lang_decl (TYPE_DECL, declarator, type);
11092         }
11093       else
11094         decl = build_decl (TYPE_DECL, declarator, type);
11095
11096       /* If the user declares "typedef struct {...} foo" then the
11097          struct will have an anonymous name.  Fill that name in now.
11098          Nothing can refer to it, so nothing needs know about the name
11099          change.  */
11100       if (type != error_mark_node
11101           && declarator
11102           && TYPE_NAME (type)
11103           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11104           && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type))
11105           && CP_TYPE_QUALS (type) == TYPE_UNQUALIFIED)
11106         {
11107           tree oldname = TYPE_NAME (type);
11108           tree t;
11109
11110           /* Replace the anonymous name with the real name everywhere.  */
11111           lookup_tag_reverse (type, declarator);
11112           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
11113             if (TYPE_NAME (t) == oldname)
11114               TYPE_NAME (t) = decl;
11115
11116           if (TYPE_LANG_SPECIFIC (type))
11117             TYPE_WAS_ANONYMOUS (type) = 1;
11118
11119           /* If this is a typedef within a template class, the nested
11120              type is a (non-primary) template.  The name for the
11121              template needs updating as well.  */
11122           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
11123             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
11124               = TYPE_IDENTIFIER (type);
11125
11126           if (flag_new_abi)
11127             DECL_ASSEMBLER_NAME (decl) = mangle_type (type);
11128           else
11129             {
11130               /* XXX Temporarily set the scope.
11131                  When returning, start_decl expects it as NULL_TREE,
11132                  and will then then set it using pushdecl. */
11133               my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 980404);
11134               if (current_class_type)
11135                 DECL_CONTEXT (decl) = current_class_type;
11136               else
11137                 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
11138
11139               DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
11140               DECL_ASSEMBLER_NAME (decl)
11141                 = get_identifier (build_overload_name (type, 1, 1));
11142               DECL_CONTEXT (decl) = NULL_TREE;
11143             }
11144
11145           /* FIXME remangle member functions; member functions of a
11146              type with external linkage have external linkage.  */
11147         }
11148
11149       if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
11150         {
11151           cp_error_at ("typedef name may not be class-qualified", decl);
11152           return NULL_TREE;
11153         }
11154       else if (quals)
11155         {
11156           if (ctype == NULL_TREE)
11157             {
11158               if (TREE_CODE (type) != METHOD_TYPE)
11159                 cp_error_at ("invalid type qualifier for non-member function type", decl);
11160               else
11161                 ctype = TYPE_METHOD_BASETYPE (type);
11162             }
11163           if (ctype != NULL_TREE)
11164             grok_method_quals (ctype, decl, quals);
11165         }
11166
11167       if (RIDBIT_SETP (RID_SIGNED, specbits)
11168           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
11169         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
11170
11171       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
11172                       inlinep, friendp, raises != NULL_TREE);
11173
11174       if (initialized)
11175         error ("typedef declaration includes an initializer");
11176
11177       return decl;
11178     }
11179
11180   /* Detect the case of an array type of unspecified size
11181      which came, as such, direct from a typedef name.
11182      We must copy the type, so that each identifier gets
11183      a distinct type, so that each identifier's size can be
11184      controlled separately by its own initializer.  */
11185
11186   if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
11187       && TYPE_DOMAIN (type) == NULL_TREE)
11188     {
11189       type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
11190     }
11191
11192   /* If this is a type name (such as, in a cast or sizeof),
11193      compute the type and return it now.  */
11194
11195   if (decl_context == TYPENAME)
11196     {
11197       /* Note that the grammar rejects storage classes
11198          in typenames, fields or parameters.  */
11199       if (type_quals != TYPE_UNQUALIFIED)
11200         type_quals = TYPE_UNQUALIFIED;
11201
11202       /* Special case: "friend class foo" looks like a TYPENAME context.  */
11203       if (friendp)
11204         {
11205           if (type_quals != TYPE_UNQUALIFIED)
11206             {
11207               cp_error ("type qualifiers specified for friend class declaration");
11208               type_quals = TYPE_UNQUALIFIED;
11209             }
11210           if (inlinep)
11211             {
11212               cp_error ("`inline' specified for friend class declaration");
11213               inlinep = 0;
11214             }
11215
11216           /* Only try to do this stuff if we didn't already give up.  */
11217           if (type != integer_type_node)
11218             {
11219               /* A friendly class?  */
11220               if (current_class_type)
11221                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
11222               else
11223                 error ("trying to make class `%s' a friend of global scope",
11224                        TYPE_NAME_STRING (type));
11225               type = void_type_node;
11226             }
11227         }
11228       else if (quals)
11229         {
11230           if (ctype == NULL_TREE)
11231             {
11232               if (TREE_CODE (type) != METHOD_TYPE)
11233                 cp_error ("invalid qualifiers on non-member function type");
11234               else
11235                 ctype = TYPE_METHOD_BASETYPE (type);
11236             }
11237           if (ctype)
11238             {
11239               tree dummy = build_decl (TYPE_DECL, declarator, type);
11240               grok_method_quals (ctype, dummy, quals);
11241               type = TREE_TYPE (dummy);
11242             }
11243         }
11244
11245       return type;
11246     }
11247   else if (declarator == NULL_TREE && decl_context != PARM
11248            && decl_context != CATCHPARM
11249            && TREE_CODE (type) != UNION_TYPE
11250            && ! bitfield)
11251     {
11252       cp_error ("abstract declarator `%T' used as declaration", type);
11253       declarator = make_anon_name ();
11254     }
11255
11256   /* `void' at top level (not within pointer)
11257      is allowed only in typedefs or type names.
11258      We don't complain about parms either, but that is because
11259      a better error message can be made later.  */
11260
11261   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
11262     {
11263       if (! declarator)
11264         error ("unnamed variable or field declared void");
11265       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
11266         {
11267           if (IDENTIFIER_OPNAME_P (declarator))
11268             my_friendly_abort (356);
11269           else
11270             error ("variable or field `%s' declared void", name);
11271         }
11272       else
11273         error ("variable or field declared void");
11274       type = integer_type_node;
11275     }
11276
11277   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11278      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
11279
11280   if (decl_context == PARM || decl_context == CATCHPARM)
11281     {
11282       if (ctype || in_namespace)
11283         error ("cannot use `::' in parameter declaration");
11284
11285       /* A parameter declared as an array of T is really a pointer to T.
11286          One declared as a function is really a pointer to a function.
11287          One declared as a member is really a pointer to member.  */
11288
11289       if (TREE_CODE (type) == ARRAY_TYPE)
11290         {
11291           /* Transfer const-ness of array into that of type pointed to.  */
11292           type = build_pointer_type (TREE_TYPE (type));
11293           type_quals = TYPE_UNQUALIFIED;
11294         }
11295       else if (TREE_CODE (type) == FUNCTION_TYPE)
11296         type = build_pointer_type (type);
11297       else if (TREE_CODE (type) == OFFSET_TYPE)
11298         type = build_pointer_type (type);
11299       else if (TREE_CODE (type) == VOID_TYPE && declarator)
11300         {
11301           error ("declaration of `%s' as void", name);
11302           return NULL_TREE;
11303         }
11304     }
11305
11306   {
11307     register tree decl;
11308
11309     if (decl_context == PARM)
11310       {
11311         decl = build_decl (PARM_DECL, declarator, type);
11312
11313         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
11314                         inlinep, friendp, raises != NULL_TREE);
11315
11316         /* Compute the type actually passed in the parmlist,
11317            for the case where there is no prototype.
11318            (For example, shorts and chars are passed as ints.)
11319            When there is a prototype, this is overridden later.  */
11320
11321         DECL_ARG_TYPE (decl) = type_promotes_to (type);
11322       }
11323     else if (decl_context == FIELD)
11324       {
11325         if (type == error_mark_node)
11326           {
11327             /* Happens when declaring arrays of sizes which
11328                are error_mark_node, for example.  */
11329             decl = NULL_TREE;
11330           }
11331         else if (in_namespace && !friendp)
11332           {
11333             /* Something like struct S { int N::j; };  */
11334             cp_error ("invalid use of `::'");
11335             decl = NULL_TREE;
11336           }
11337         else if (TREE_CODE (type) == FUNCTION_TYPE)
11338           {
11339             int publicp = 0;
11340             tree function_context;
11341
11342             /* We catch the others as conflicts with the builtin
11343                typedefs.  */
11344             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11345               {
11346                 cp_error ("function `%D' cannot be declared friend",
11347                           declarator);
11348                 friendp = 0;
11349               }
11350
11351             if (friendp == 0)
11352               {
11353                 if (ctype == NULL_TREE)
11354                   ctype = current_class_type;
11355
11356                 if (ctype == NULL_TREE)
11357                   {
11358                     cp_error ("can't make `%D' into a method -- not in a class",
11359                               declarator);
11360                     return void_type_node;
11361                   }
11362
11363                 /* ``A union may [ ... ] not [ have ] virtual functions.''
11364                    ARM 9.5 */
11365                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11366                   {
11367                     cp_error ("function `%D' declared virtual inside a union",
11368                               declarator);
11369                     return void_type_node;
11370                   }
11371
11372                 if (declarator == ansi_opname (NEW_EXPR)
11373                     || declarator == ansi_opname (VEC_NEW_EXPR)
11374                     || declarator == ansi_opname (DELETE_EXPR)
11375                     || declarator == ansi_opname (VEC_DELETE_EXPR))
11376                   {
11377                     if (virtualp)
11378                       {
11379                         cp_error ("`%D' cannot be declared virtual, since it is always static",
11380                                   declarator);
11381                         virtualp = 0;
11382                       }
11383                   }
11384                 else if (staticp < 2)
11385                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11386                                                   TYPE_ARG_TYPES (type));
11387               }
11388
11389             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
11390             function_context = (ctype != NULL_TREE) ?
11391               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11392             publicp = (! friendp || ! staticp)
11393               && function_context == NULL_TREE;
11394             decl = grokfndecl (ctype, type,
11395                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11396                                ? declarator : dname,
11397                                declarator,
11398                                virtualp, flags, quals, raises,
11399                                friendp ? -1 : 0, friendp, publicp, inlinep,
11400                                funcdef_flag, template_count, in_namespace);
11401             if (decl == NULL_TREE)
11402               return decl;
11403 #if 0
11404             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
11405             /* The decl and setting of decl_machine_attr is also turned off.  */
11406             decl = build_decl_attribute_variant (decl, decl_machine_attr);
11407 #endif
11408
11409             /* [class.conv.ctor]
11410
11411                A constructor declared without the function-specifier
11412                explicit that can be called with a single parameter
11413                specifies a conversion from the type of its first
11414                parameter to the type of its class.  Such a constructor
11415                is called a converting constructor.  */
11416             if (explicitp == 2)
11417               DECL_NONCONVERTING_P (decl) = 1;
11418             else if (DECL_CONSTRUCTOR_P (decl))
11419               {
11420                 /* The constructor can be called with exactly one
11421                    parameter if there is at least one parameter, and
11422                    any subsequent parameters have default arguments.
11423                    We don't look at the first parameter, which is
11424                    really just the `this' parameter for the new
11425                    object.  */
11426                 tree arg_types =
11427                   TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)));
11428
11429                 /* Skip the `in_chrg' argument too, if present.  */
11430                 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
11431                   arg_types = TREE_CHAIN (arg_types);
11432
11433                 if (arg_types == void_list_node
11434                     || (arg_types
11435                         && TREE_CHAIN (arg_types)
11436                         && TREE_CHAIN (arg_types) != void_list_node
11437                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11438                   DECL_NONCONVERTING_P (decl) = 1;
11439               }
11440           }
11441         else if (TREE_CODE (type) == METHOD_TYPE)
11442           {
11443             /* We only get here for friend declarations of
11444                members of other classes.  */
11445             /* All method decls are public, so tell grokfndecl to set
11446                TREE_PUBLIC, also.  */
11447             decl = grokfndecl (ctype, type, declarator, declarator,
11448                                virtualp, flags, quals, raises,
11449                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11450                                template_count, in_namespace);
11451             if (decl == NULL_TREE)
11452               return NULL_TREE;
11453           }
11454         else if (!staticp && ! processing_template_decl
11455                  && !COMPLETE_TYPE_P (complete_type (type))
11456                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11457           {
11458             if (declarator)
11459               cp_error ("field `%D' has incomplete type", declarator);
11460             else
11461               cp_error ("name `%T' has incomplete type", type);
11462
11463             /* If we're instantiating a template, tell them which
11464                instantiation made the field's type be incomplete.  */
11465             if (current_class_type
11466                 && TYPE_NAME (current_class_type)
11467                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11468                 && declspecs && TREE_VALUE (declspecs)
11469                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11470               cp_error ("  in instantiation of template `%T'",
11471                         current_class_type);
11472
11473             type = error_mark_node;
11474             decl = NULL_TREE;
11475           }
11476         else
11477           {
11478             if (friendp)
11479               {
11480                 error ("`%s' is neither function nor member function; cannot be declared friend",
11481                        IDENTIFIER_POINTER (declarator));
11482                 friendp = 0;
11483               }
11484             decl = NULL_TREE;
11485           }
11486
11487         if (friendp)
11488           {
11489             /* Friends are treated specially.  */
11490             if (ctype == current_class_type)
11491               warning ("member functions are implicitly friends of their class");
11492             else
11493               {
11494                 tree t = NULL_TREE;
11495                 if (decl && DECL_NAME (decl))
11496                   {
11497                     if (template_class_depth (current_class_type) == 0)
11498                       {
11499                         decl
11500                           = check_explicit_specialization
11501                           (declarator, decl,
11502                            template_count, 2 * (funcdef_flag != 0) + 4);
11503                         if (decl == error_mark_node)
11504                           return error_mark_node;
11505                       }
11506
11507                     t = do_friend (ctype, declarator, decl,
11508                                    last_function_parms, attrlist, flags, quals,
11509                                    funcdef_flag);
11510                   }
11511                 if (t && funcdef_flag)
11512                   return t;
11513
11514                 return void_type_node;
11515               }
11516           }
11517
11518         /* Structure field.  It may not be a function, except for C++ */
11519
11520         if (decl == NULL_TREE)
11521           {
11522             if (initialized)
11523               {
11524                 if (!staticp)
11525                   {
11526                     /* An attempt is being made to initialize a non-static
11527                        member.  But, from [class.mem]:
11528
11529                        4 A member-declarator can contain a
11530                        constant-initializer only if it declares a static
11531                        member (_class.static_) of integral or enumeration
11532                        type, see _class.static.data_.
11533
11534                        This used to be relatively common practice, but
11535                        the rest of the compiler does not correctly
11536                        handle the initialization unless the member is
11537                        static so we make it static below.  */
11538                     cp_pedwarn ("ISO C++ forbids initialization of member `%D'",
11539                                 declarator);
11540                     cp_pedwarn ("making `%D' static", declarator);
11541                     staticp = 1;
11542                   }
11543
11544                 if (uses_template_parms (type))
11545                   /* We'll check at instantiation time.  */
11546                   ;
11547                 else if (check_static_variable_definition (declarator,
11548                                                            type))
11549                   /* If we just return the declaration, crashes
11550                      will sometimes occur.  We therefore return
11551                      void_type_node, as if this was a friend
11552                      declaration, to cause callers to completely
11553                      ignore this declaration.  */
11554                   return void_type_node;
11555               }
11556
11557             /* 9.2p13 [class.mem] */
11558             if (declarator == constructor_name (current_class_type)
11559                 /* The standard does not allow non-static data members
11560                    here either, but we agreed at the 10/99 meeting
11561                    to change that in TC 1 so that they are allowed in
11562                    classes with no user-defined constructors.  */
11563                 && staticp)
11564               cp_pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
11565                           declarator);
11566
11567             if (staticp)
11568               {
11569                 /* C++ allows static class members.  All other work
11570                    for this is done by grokfield.  */
11571                 decl = build_lang_decl (VAR_DECL, declarator, type);
11572                 TREE_STATIC (decl) = 1;
11573                 /* In class context, 'static' means public access.  */
11574                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11575               }
11576             else
11577               {
11578                 decl = build_decl (FIELD_DECL, declarator, type);
11579                 DECL_NONADDRESSABLE_P (decl) = bitfield;
11580                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11581                   {
11582                     DECL_MUTABLE_P (decl) = 1;
11583                     RIDBIT_RESET (RID_MUTABLE, specbits);
11584                   }
11585               }
11586
11587             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11588                             inlinep, friendp, raises != NULL_TREE);
11589           }
11590       }
11591     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11592       {
11593         tree original_name;
11594         int publicp = 0;
11595
11596         if (! declarator)
11597           return NULL_TREE;
11598
11599         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11600           original_name = dname;
11601         else
11602           original_name = declarator;
11603
11604         if (RIDBIT_SETP (RID_AUTO, specbits))
11605           error ("storage class `auto' invalid for function `%s'", name);
11606         else if (RIDBIT_SETP (RID_REGISTER, specbits))
11607           error ("storage class `register' invalid for function `%s'", name);
11608
11609         /* Function declaration not at top level.
11610            Storage classes other than `extern' are not allowed
11611            and `extern' makes no difference.  */
11612         if (! toplevel_bindings_p ()
11613             && (RIDBIT_SETP (RID_STATIC, specbits)
11614                 || RIDBIT_SETP (RID_INLINE, specbits))
11615             && pedantic)
11616           {
11617             if (RIDBIT_SETP (RID_STATIC, specbits))
11618               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11619             else
11620               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11621           }
11622
11623         if (ctype == NULL_TREE)
11624           {
11625             if (virtualp)
11626               {
11627                 error ("virtual non-class function `%s'", name);
11628                 virtualp = 0;
11629               }
11630           }
11631         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11632           type = build_cplus_method_type (ctype, TREE_TYPE (type),
11633                                           TYPE_ARG_TYPES (type));
11634
11635         /* Record presence of `static'.  */
11636         publicp = (ctype != NULL_TREE
11637                    || RIDBIT_SETP (RID_EXTERN, specbits)
11638                    || !RIDBIT_SETP (RID_STATIC, specbits));
11639
11640         decl = grokfndecl (ctype, type, original_name, declarator,
11641                            virtualp, flags, quals, raises,
11642                            1, friendp,
11643                            publicp, inlinep, funcdef_flag,
11644                            template_count, in_namespace);
11645         if (decl == NULL_TREE)
11646           return NULL_TREE;
11647
11648         if (staticp == 1)
11649           {
11650             int illegal_static = 0;
11651
11652             /* Don't allow a static member function in a class, and forbid
11653                declaring main to be static.  */
11654             if (TREE_CODE (type) == METHOD_TYPE)
11655               {
11656                 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11657                 illegal_static = 1;
11658               }
11659             else if (current_function_decl)
11660               {
11661                 /* FIXME need arm citation */
11662                 error ("cannot declare static function inside another function");
11663                 illegal_static = 1;
11664               }
11665
11666             if (illegal_static)
11667               {
11668                 staticp = 0;
11669                 RIDBIT_RESET (RID_STATIC, specbits);
11670               }
11671           }
11672       }
11673     else
11674       {
11675         /* It's a variable.  */
11676
11677         /* An uninitialized decl with `extern' is a reference.  */
11678         decl = grokvardecl (type, declarator, &specbits,
11679                             initialized,
11680                             (type_quals & TYPE_QUAL_CONST) != 0,
11681                             in_namespace);
11682         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11683                         inlinep, friendp, raises != NULL_TREE);
11684
11685         if (ctype)
11686           {
11687             DECL_CONTEXT (decl) = ctype;
11688             if (staticp == 1)
11689               {
11690                 cp_pedwarn ("static member `%D' re-declared as static", decl);
11691                 staticp = 0;
11692                 RIDBIT_RESET (RID_STATIC, specbits);
11693               }
11694             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11695               {
11696                 cp_error ("static member `%D' declared `register'", decl);
11697                 RIDBIT_RESET (RID_REGISTER, specbits);
11698               }
11699             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11700               {
11701                 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11702                             decl);
11703                 RIDBIT_RESET (RID_EXTERN, specbits);
11704               }
11705           }
11706       }
11707
11708     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11709
11710     /* Record `register' declaration for warnings on &
11711        and in case doing stupid register allocation.  */
11712
11713     if (RIDBIT_SETP (RID_REGISTER, specbits))
11714       DECL_REGISTER (decl) = 1;
11715
11716     if (RIDBIT_SETP (RID_EXTERN, specbits))
11717       DECL_THIS_EXTERN (decl) = 1;
11718
11719     if (RIDBIT_SETP (RID_STATIC, specbits))
11720       DECL_THIS_STATIC (decl) = 1;
11721
11722     /* Record constancy and volatility.  There's no need to do this
11723        when processing a template; we'll do this for the instantiated
11724        declaration based on the type of DECL.  */
11725     if (!processing_template_decl)
11726       c_apply_type_quals_to_decl (type_quals, decl);
11727
11728     return decl;
11729   }
11730 }
11731 \f
11732 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11733    An empty exprlist is a parmlist.  An exprlist which
11734    contains only identifiers at the global level
11735    is a parmlist.  Otherwise, it is an exprlist.  */
11736
11737 int
11738 parmlist_is_exprlist (exprs)
11739      tree exprs;
11740 {
11741   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11742     return 0;
11743
11744   if (toplevel_bindings_p ())
11745     {
11746       /* At the global level, if these are all identifiers,
11747          then it is a parmlist.  */
11748       while (exprs)
11749         {
11750           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11751             return 1;
11752           exprs = TREE_CHAIN (exprs);
11753         }
11754       return 0;
11755     }
11756   return 1;
11757 }
11758
11759 /* Subroutine of start_function.  Ensure that each of the parameter
11760    types (as listed in PARMS) is complete, as is required for a
11761    function definition.  */
11762
11763 static void
11764 require_complete_types_for_parms (parms)
11765      tree parms;
11766 {
11767   for (; parms; parms = TREE_CHAIN (parms))
11768     {
11769       tree type = TREE_TYPE (parms);
11770
11771       /* Try to complete the TYPE.  */
11772       type = complete_type (type);
11773
11774       if (type == error_mark_node)
11775         continue;
11776
11777       if (!COMPLETE_TYPE_P (type))
11778         {
11779           if (DECL_NAME (parms))
11780             error ("parameter `%s' has incomplete type",
11781                    IDENTIFIER_POINTER (DECL_NAME (parms)));
11782           else
11783             error ("parameter has incomplete type");
11784           TREE_TYPE (parms) = error_mark_node;
11785         }
11786       else
11787         layout_decl (parms, 0);
11788     }
11789 }
11790
11791 /* Returns non-zero if T is a local variable.  */
11792
11793 int
11794 local_variable_p (t)
11795      tree t;
11796 {
11797   if ((TREE_CODE (t) == VAR_DECL
11798        /* A VAR_DECL with a context that is a _TYPE is a static data
11799           member.  */
11800        && !TYPE_P (CP_DECL_CONTEXT (t))
11801        /* Any other non-local variable must be at namespace scope.  */
11802        && !DECL_NAMESPACE_SCOPE_P (t))
11803       || (TREE_CODE (t) == PARM_DECL))
11804     return 1;
11805
11806   return 0;
11807 }
11808
11809 /* Returns non-zero if T is an automatic local variable or a label.
11810    (These are the declarations that need to be remapped when the code
11811    containing them is duplicated.)  */
11812
11813 int
11814 nonstatic_local_decl_p (t)
11815      tree t;
11816 {
11817   return ((local_variable_p (t) && !TREE_STATIC (t))
11818           || TREE_CODE (t) == LABEL_DECL
11819           || TREE_CODE (t) == RESULT_DECL);
11820 }
11821
11822 /* Like local_variable_p, but suitable for use as a tree-walking
11823    function.  */
11824
11825 static tree
11826 local_variable_p_walkfn (tp, walk_subtrees, data)
11827      tree *tp;
11828      int *walk_subtrees ATTRIBUTE_UNUSED;
11829      void *data ATTRIBUTE_UNUSED;
11830 {
11831   return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
11832           ? *tp : NULL_TREE);
11833 }
11834
11835 /* Check that ARG, which is a default-argument expression for a
11836    parameter DECL, is legal.  Returns ARG, or ERROR_MARK_NODE, if
11837    something goes wrong.  DECL may also be a _TYPE node, rather than a
11838    DECL, if there is no DECL available.  */
11839
11840 tree
11841 check_default_argument (decl, arg)
11842      tree decl;
11843      tree arg;
11844 {
11845   tree var;
11846   tree decl_type;
11847
11848   if (TREE_CODE (arg) == DEFAULT_ARG)
11849     /* We get a DEFAULT_ARG when looking at an in-class declaration
11850        with a default argument.  Ignore the argument for now; we'll
11851        deal with it after the class is complete.  */
11852     return arg;
11853
11854   if (processing_template_decl || uses_template_parms (arg))
11855     /* We don't do anything checking until instantiation-time.  Note
11856        that there may be uninstantiated arguments even for an
11857        instantiated function, since default arguments are not
11858        instantiated until they are needed.  */
11859     return arg;
11860
11861   if (TYPE_P (decl))
11862     {
11863       decl_type = decl;
11864       decl = NULL_TREE;
11865     }
11866   else
11867     decl_type = TREE_TYPE (decl);
11868
11869   if (arg == error_mark_node
11870       || decl == error_mark_node
11871       || TREE_TYPE (arg) == error_mark_node
11872       || decl_type == error_mark_node)
11873     /* Something already went wrong.  There's no need to check
11874        further.  */
11875     return error_mark_node;
11876
11877   /* [dcl.fct.default]
11878
11879      A default argument expression is implicitly converted to the
11880      parameter type.  */
11881   if (!TREE_TYPE (arg)
11882       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
11883     {
11884       if (decl)
11885         cp_error ("default argument for `%#D' has type `%T'",
11886                   decl, TREE_TYPE (arg));
11887       else
11888         cp_error ("default argument for parameter of type `%T' has type `%T'",
11889                   decl_type, TREE_TYPE (arg));
11890
11891       return error_mark_node;
11892     }
11893
11894   /* [dcl.fct.default]
11895
11896      Local variables shall not be used in default argument
11897      expressions.
11898
11899      The keyword `this' shall not be used in a default argument of a
11900      member function.  */
11901   var = walk_tree (&arg, local_variable_p_walkfn, NULL);
11902   if (var)
11903     {
11904       cp_error ("default argument `%E' uses local variable `%D'",
11905                 arg, var);
11906       return error_mark_node;
11907     }
11908
11909   /* All is well.  */
11910   return arg;
11911 }
11912
11913 /* Decode the list of parameter types for a function type.
11914    Given the list of things declared inside the parens,
11915    return a list of types.
11916
11917    The list we receive can have three kinds of elements:
11918    an IDENTIFIER_NODE for names given without types,
11919    a TREE_LIST node for arguments given as typespecs or names with typespecs,
11920    or void_type_node, to mark the end of an argument list
11921    when additional arguments are not permitted (... was not used).
11922
11923    FUNCDEF_FLAG is nonzero for a function definition, 0 for
11924    a mere declaration.  A nonempty identifier-list gets an error message
11925    when FUNCDEF_FLAG is zero.
11926    If FUNCDEF_FLAG is 1, then parameter types must be complete.
11927    If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
11928
11929    If all elements of the input list contain types,
11930    we return a list of the types.
11931    If all elements contain no type (except perhaps a void_type_node
11932    at the end), we return a null list.
11933    If some have types and some do not, it is an error, and we
11934    return a null list.
11935
11936    Also set last_function_parms to either
11937    a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
11938    A list of names is converted to a chain of PARM_DECLs
11939    by store_parm_decls so that ultimately it is always a chain of decls.
11940
11941    Note that in C++, parameters can take default values.  These default
11942    values are in the TREE_PURPOSE field of the TREE_LIST.  It is
11943    an error to specify default values which are followed by parameters
11944    that have no default values, or an ELLIPSES.  For simplicities sake,
11945    only parameters which are specified with their types can take on
11946    default values.  */
11947
11948 static tree
11949 grokparms (first_parm, funcdef_flag)
11950      tree first_parm;
11951      int funcdef_flag;
11952 {
11953   tree result = NULL_TREE;
11954   tree decls = NULL_TREE;
11955
11956   if (first_parm != NULL_TREE
11957       && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
11958     {
11959       if (! funcdef_flag)
11960         pedwarn ("parameter names (without types) in function declaration");
11961       last_function_parms = first_parm;
11962       return NULL_TREE;
11963     }
11964   else if (first_parm != NULL_TREE
11965            && TREE_CODE (TREE_VALUE (first_parm)) != TREE_LIST
11966            && TREE_CODE (TREE_VALUE (first_parm)) != VOID_TYPE)
11967     my_friendly_abort (145);
11968   else
11969     {
11970       /* Types were specified.  This is a list of declarators
11971          each represented as a TREE_LIST node.  */
11972       register tree parm, chain;
11973       int any_init = 0, any_error = 0;
11974
11975       if (first_parm != NULL_TREE)
11976         {
11977           tree last_result = NULL_TREE;
11978           tree last_decl = NULL_TREE;
11979
11980           for (parm = first_parm; parm != NULL_TREE; parm = chain)
11981             {
11982               tree type = NULL_TREE, list_node = parm;
11983               register tree decl = TREE_VALUE (parm);
11984               tree init = TREE_PURPOSE (parm);
11985
11986               chain = TREE_CHAIN (parm);
11987               /* @@ weak defense against parse errors.  */
11988               if (TREE_CODE (decl) != VOID_TYPE
11989                   && TREE_CODE (decl) != TREE_LIST)
11990                 {
11991                   /* Give various messages as the need arises.  */
11992                   if (TREE_CODE (decl) == STRING_CST)
11993                     cp_error ("invalid string constant `%E'", decl);
11994                   else if (TREE_CODE (decl) == INTEGER_CST)
11995                     error ("invalid integer constant in parameter list, did you forget to give parameter name?");
11996                   continue;
11997                 }
11998
11999               if (TREE_CODE (decl) != VOID_TYPE)
12000                 {
12001                   decl = grokdeclarator (TREE_VALUE (decl),
12002                                          TREE_PURPOSE (decl),
12003                                          PARM, init != NULL_TREE,
12004                                          NULL_TREE);
12005                   if (! decl || TREE_TYPE (decl) == error_mark_node)
12006                     continue;
12007
12008                   /* Top-level qualifiers on the parameters are
12009                      ignored for function types.  */
12010                   type = TYPE_MAIN_VARIANT (TREE_TYPE (decl));
12011
12012                   if (TREE_CODE (type) == VOID_TYPE)
12013                     decl = void_type_node;
12014                   else if (TREE_CODE (type) == METHOD_TYPE)
12015                     {
12016                       if (DECL_NAME (decl))
12017                         /* Cannot use the decl here because
12018                            we don't have DECL_CONTEXT set up yet.  */
12019                         cp_error ("parameter `%D' invalidly declared method type",
12020                                   DECL_NAME (decl));
12021                       else
12022                         error ("parameter invalidly declared method type");
12023                       type = build_pointer_type (type);
12024                       TREE_TYPE (decl) = type;
12025                     }
12026                   else if (TREE_CODE (type) == OFFSET_TYPE)
12027                     {
12028                       if (DECL_NAME (decl))
12029                         cp_error ("parameter `%D' invalidly declared offset type",
12030                                   DECL_NAME (decl));
12031                       else
12032                         error ("parameter invalidly declared offset type");
12033                       type = build_pointer_type (type);
12034                       TREE_TYPE (decl) = type;
12035                     }
12036                   else if (abstract_virtuals_error (decl, type))
12037                     any_error = 1;  /* Seems like a good idea. */
12038                   else if (POINTER_TYPE_P (type))
12039                     {
12040                       tree t = type;
12041                       while (POINTER_TYPE_P (t)
12042                              || (TREE_CODE (t) == ARRAY_TYPE
12043                                  && TYPE_DOMAIN (t) != NULL_TREE))
12044                         t = TREE_TYPE (t);
12045                       if (TREE_CODE (t) == ARRAY_TYPE)
12046                         cp_error ("parameter type `%T' includes %s to array of unknown bound",
12047                                   type,
12048                                   TYPE_PTR_P (type) ? "pointer" : "reference");
12049                     }
12050                 }
12051
12052               if (TREE_CODE (decl) == VOID_TYPE)
12053                 {
12054                   if (result == NULL_TREE)
12055                     {
12056                       result = void_list_node;
12057                       last_result = result;
12058                     }
12059                   else
12060                     {
12061                       TREE_CHAIN (last_result) = void_list_node;
12062                       last_result = void_list_node;
12063                     }
12064                   if (chain
12065                       && (chain != void_list_node || TREE_CHAIN (chain)))
12066                     error ("`void' in parameter list must be entire list");
12067                   break;
12068                 }
12069
12070               /* Since there is a prototype, args are passed in their own types.  */
12071               DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
12072               if (PROMOTE_PROTOTYPES
12073                   && (TREE_CODE (type) == INTEGER_TYPE
12074                       || TREE_CODE (type) == ENUMERAL_TYPE)
12075                   && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
12076                 DECL_ARG_TYPE (decl) = integer_type_node;
12077               if (!any_error && init)
12078                 {
12079                   any_init++;
12080                   init = check_default_argument (decl, init);
12081                 }
12082               else
12083                 init = NULL_TREE;
12084
12085               if (decls == NULL_TREE)
12086                 {
12087                   decls = decl;
12088                   last_decl = decls;
12089                 }
12090               else
12091                 {
12092                   TREE_CHAIN (last_decl) = decl;
12093                   last_decl = decl;
12094                 }
12095               list_node = tree_cons (init, type, NULL_TREE);
12096               if (result == NULL_TREE)
12097                 {
12098                   result = list_node;
12099                   last_result = result;
12100                 }
12101               else
12102                 {
12103                   TREE_CHAIN (last_result) = list_node;
12104                   last_result = list_node;
12105                 }
12106             }
12107           if (last_result)
12108             TREE_CHAIN (last_result) = NULL_TREE;
12109           /* If there are no parameters, and the function does not end
12110              with `...', then last_decl will be NULL_TREE.  */
12111           if (last_decl != NULL_TREE)
12112             TREE_CHAIN (last_decl) = NULL_TREE;
12113         }
12114     }
12115
12116   last_function_parms = decls;
12117
12118   return result;
12119 }
12120
12121 /* Called from the parser to update an element of TYPE_ARG_TYPES for some
12122    FUNCTION_TYPE with the newly parsed version of its default argument, which
12123    was previously digested as text.  See snarf_defarg et al in lex.c.  */
12124
12125 void
12126 replace_defarg (arg, init)
12127      tree arg, init;
12128 {
12129   if (! processing_template_decl
12130       && ! can_convert_arg (TREE_VALUE (arg), TREE_TYPE (init), init))
12131     cp_pedwarn ("invalid type `%T' for default argument to `%T'",
12132                 TREE_TYPE (init), TREE_VALUE (arg));
12133   TREE_PURPOSE (arg) = init;
12134 }
12135 \f
12136 /* D is a constructor or overloaded `operator='.  Returns non-zero if
12137    D's arguments allow it to be a copy constructor, or copy assignment
12138    operator.  */
12139
12140 int
12141 copy_args_p (d)
12142      tree d;
12143 {
12144   tree t;
12145
12146   if (!DECL_FUNCTION_MEMBER_P (d))
12147     return 0;
12148
12149   t = FUNCTION_ARG_CHAIN (d);
12150   if (DECL_CONSTRUCTOR_P (d) && DECL_HAS_IN_CHARGE_PARM_P (d))
12151     t = TREE_CHAIN (t);
12152   if (t && TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
12153       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t)))
12154           == DECL_CONTEXT (d))
12155       && (TREE_CHAIN (t) == NULL_TREE
12156           || TREE_CHAIN (t) == void_list_node
12157           || TREE_PURPOSE (TREE_CHAIN (t))))
12158     return 1;
12159   return 0;
12160 }
12161
12162 /* These memoizing functions keep track of special properties which
12163    a class may have.  `grok_ctor_properties' notices whether a class
12164    has a constructor of the form X(X&), and also complains
12165    if the class has a constructor of the form X(X).
12166    `grok_op_properties' takes notice of the various forms of
12167    operator= which are defined, as well as what sorts of type conversion
12168    may apply.  Both functions take a FUNCTION_DECL as an argument.  */
12169
12170 int
12171 grok_ctor_properties (ctype, decl)
12172      tree ctype, decl;
12173 {
12174   tree parmtypes = FUNCTION_ARG_CHAIN (decl);
12175   tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
12176
12177   /* When a type has virtual baseclasses, a magical first int argument is
12178      added to any ctor so we can tell if the class has been initialized
12179      yet.  This could screw things up in this function, so we deliberately
12180      ignore the leading int if we're in that situation.  */
12181   if (DECL_HAS_IN_CHARGE_PARM_P (decl))
12182     {
12183       my_friendly_assert (parmtypes
12184                           && TREE_VALUE (parmtypes) == integer_type_node,
12185                           980529);
12186       parmtypes = TREE_CHAIN (parmtypes);
12187       parmtype = TREE_VALUE (parmtypes);
12188     }
12189
12190   /* [class.copy]
12191
12192      A non-template constructor for class X is a copy constructor if
12193      its first parameter is of type X&, const X&, volatile X& or const
12194      volatile X&, and either there are no other parameters or else all
12195      other parameters have default arguments.  */
12196   if (TREE_CODE (parmtype) == REFERENCE_TYPE
12197       && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype
12198       && (TREE_CHAIN (parmtypes) == NULL_TREE
12199           || TREE_CHAIN (parmtypes) == void_list_node
12200           || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
12201       && !(DECL_TEMPLATE_INSTANTIATION (decl)
12202            && is_member_template (DECL_TI_TEMPLATE (decl))))
12203     {
12204       TYPE_HAS_INIT_REF (ctype) = 1;
12205       if (CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12206         TYPE_HAS_CONST_INIT_REF (ctype) = 1;
12207     }
12208   /* [class.copy]
12209
12210      A declaration of a constructor for a class X is ill-formed if its
12211      first parameter is of type (optionally cv-qualified) X and either
12212      there are no other parameters or else all other parameters have
12213      default arguments.
12214
12215      We *don't* complain about member template instantiations that
12216      have this form, though; they can occur as we try to decide what
12217      constructor to use during overload resolution.  Since overload
12218      resolution will never prefer such a constructor to the
12219      non-template copy constructor (which is either explicitly or
12220      implicitly defined), there's no need to worry about their
12221      existence.  Theoretically, they should never even be
12222      instantiated, but that's hard to forestall.  */
12223   else if (TYPE_MAIN_VARIANT (parmtype) == ctype
12224            && (TREE_CHAIN (parmtypes) == NULL_TREE
12225                || TREE_CHAIN (parmtypes) == void_list_node
12226                || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
12227            && !(DECL_TEMPLATE_INSTANTIATION (decl)
12228                 && is_member_template (DECL_TI_TEMPLATE (decl))))
12229     {
12230       cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
12231                 ctype, ctype);
12232       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
12233       return 0;
12234     }
12235   else if (TREE_CODE (parmtype) == VOID_TYPE
12236            || TREE_PURPOSE (parmtypes) != NULL_TREE)
12237     TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
12238
12239   return 1;
12240 }
12241
12242 /* An operator with this code is unary, but can also be binary.  */
12243
12244 static int
12245 ambi_op_p (code)
12246      enum tree_code code;
12247 {
12248   return (code == INDIRECT_REF
12249           || code == ADDR_EXPR
12250           || code == CONVERT_EXPR
12251           || code == NEGATE_EXPR
12252           || code == PREINCREMENT_EXPR
12253           || code == PREDECREMENT_EXPR);
12254 }
12255
12256 /* An operator with this name can only be unary.  */
12257
12258 static int
12259 unary_op_p (code)
12260      enum tree_code code;
12261 {
12262   return (code == TRUTH_NOT_EXPR
12263           || code == BIT_NOT_EXPR
12264           || code == COMPONENT_REF
12265           || code == TYPE_EXPR);
12266 }
12267
12268 /* Do a little sanity-checking on how they declared their operator.  */
12269
12270 void
12271 grok_op_properties (decl, virtualp, friendp)
12272      tree decl;
12273      int virtualp, friendp;
12274 {
12275   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
12276   tree argtype;
12277   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
12278   tree name = DECL_NAME (decl);
12279   enum tree_code operator_code;
12280   int arity;
12281
12282   /* Count the number of arguments.  */
12283   for (argtype = argtypes, arity = 0;
12284        argtype && argtype != void_list_node;
12285        argtype = TREE_CHAIN (argtype))
12286     ++arity;
12287
12288   if (current_class_type == NULL_TREE)
12289     friendp = 1;
12290
12291   if (DECL_CONV_FN_P (decl))
12292     operator_code = TYPE_EXPR;
12293   else
12294     do
12295       {
12296 #define DEF_OPERATOR(NAME, CODE, NEW_MANGLING, OLD_MANGING, ARITY, ASSN_P)  \
12297         if (ansi_opname (CODE) == name)                                     \
12298           {                                                                 \
12299             operator_code = CODE;                                           \
12300             break;                                                          \
12301           }                                                                 \
12302         else if (ansi_assopname (CODE) == name)                             \
12303           {                                                                 \
12304             operator_code = CODE;                                           \
12305             DECL_ASSIGNMENT_OPERATOR_P (decl) = 1;                          \
12306             break;                                                          \
12307           }
12308
12309 #include "operators.def"
12310 #undef DEF_OPERATOR
12311
12312         my_friendly_abort (20000527);
12313       }
12314     while (0);
12315   my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526);
12316   SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12317
12318   if (! friendp)
12319     {
12320       switch (operator_code)
12321         {
12322         case CALL_EXPR:
12323           TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
12324           break;
12325
12326         case ARRAY_REF:
12327           TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
12328           break;
12329
12330         case COMPONENT_REF:
12331         case MEMBER_REF:
12332           TYPE_OVERLOADS_ARROW (current_class_type) = 1;
12333           break;
12334
12335         case NEW_EXPR:
12336           TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
12337           break;
12338
12339         case DELETE_EXPR:
12340           TYPE_GETS_DELETE (current_class_type) |= 1;
12341           break;
12342
12343         case VEC_NEW_EXPR:
12344           TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
12345           break;
12346
12347         case VEC_DELETE_EXPR:
12348           TYPE_GETS_DELETE (current_class_type) |= 2;
12349           break;
12350
12351         default:
12352           break;
12353         }
12354     }
12355
12356   if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
12357     {
12358       /* When the compiler encounters the definition of A::operator new, it
12359          doesn't look at the class declaration to find out if it's static.  */
12360       if (methodp)
12361         revert_static_member_fn (decl);
12362
12363       /* Take care of function decl if we had syntax errors.  */
12364       if (argtypes == NULL_TREE)
12365         TREE_TYPE (decl)
12366           = build_function_type (ptr_type_node,
12367                                  hash_tree_chain (integer_type_node,
12368                                                   void_list_node));
12369       else
12370         TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12371     }
12372   else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
12373     {
12374       if (methodp)
12375         revert_static_member_fn (decl);
12376
12377       if (argtypes == NULL_TREE)
12378         TREE_TYPE (decl)
12379           = build_function_type (void_type_node,
12380                                  hash_tree_chain (ptr_type_node,
12381                                                   void_list_node));
12382       else
12383         TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12384     }
12385   else
12386     {
12387       /* An operator function must either be a non-static member function
12388          or have at least one parameter of a class, a reference to a class,
12389          an enumeration, or a reference to an enumeration.  13.4.0.6 */
12390       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12391         {
12392           if (operator_code == TYPE_EXPR
12393               || operator_code == CALL_EXPR
12394               || operator_code == COMPONENT_REF
12395               || operator_code == ARRAY_REF
12396               || operator_code == NOP_EXPR)
12397             cp_error ("`%D' must be a nonstatic member function", decl);
12398           else
12399             {
12400               tree p = argtypes;
12401
12402               if (DECL_STATIC_FUNCTION_P (decl))
12403                 cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
12404
12405               if (p)
12406                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12407                   {
12408                     tree arg = TREE_VALUE (p);
12409                     if (TREE_CODE (arg) == REFERENCE_TYPE)
12410                       arg = TREE_TYPE (arg);
12411
12412                     /* This lets bad template code slip through.  */
12413                     if (IS_AGGR_TYPE (arg)
12414                         || TREE_CODE (arg) == ENUMERAL_TYPE
12415                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12416                         || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
12417                       goto foundaggr;
12418                   }
12419               cp_error
12420                 ("`%D' must have an argument of class or enumerated type",
12421                  decl);
12422             foundaggr:
12423               ;
12424             }
12425         }
12426
12427       if (operator_code == CALL_EXPR)
12428         return;                 /* No restrictions on args. */
12429
12430       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12431         {
12432           tree t = TREE_TYPE (name);
12433           if (! friendp)
12434             {
12435               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12436               const char *what = 0;
12437
12438               if (ref)
12439                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12440
12441               if (TREE_CODE (t) == VOID_TYPE)
12442                 what = "void";
12443               else if (t == current_class_type)
12444                 what = "the same type";
12445               /* Don't force t to be complete here.  */
12446               else if (IS_AGGR_TYPE (t)
12447                        && COMPLETE_TYPE_P (t)
12448                        && DERIVED_FROM_P (t, current_class_type))
12449                 what = "a base class";
12450
12451               if (what)
12452                 warning ("conversion to %s%s will never use a type conversion operator",
12453                          ref ? "a reference to " : "", what);
12454             }
12455         }
12456
12457       if (DECL_ASSIGNMENT_OPERATOR_P (decl)
12458           && operator_code == NOP_EXPR)
12459         {
12460           tree parmtype;
12461
12462           if (arity != 2 && methodp)
12463             {
12464               cp_error ("`%D' must take exactly one argument", decl);
12465               return;
12466             }
12467           parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
12468
12469           /* [class.copy]
12470
12471              A user-declared copy assignment operator X::operator= is
12472              a non-static non-template member function of class X with
12473              exactly one parameter of type X, X&, const X&, volatile
12474              X& or const volatile X&.  */
12475           if (copy_assignment_arg_p (parmtype, virtualp)
12476               && !(DECL_TEMPLATE_INSTANTIATION (decl)
12477                    && is_member_template (DECL_TI_TEMPLATE (decl)))
12478               && ! friendp)
12479             {
12480               TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
12481               if (TREE_CODE (parmtype) != REFERENCE_TYPE
12482                   || CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12483                 TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
12484             }
12485         }
12486       else if (operator_code == COND_EXPR)
12487         {
12488           /* 13.4.0.3 */
12489           cp_error ("ISO C++ prohibits overloading operator ?:");
12490         }
12491       else if (ambi_op_p (operator_code))
12492         {
12493           if (arity == 1)
12494             /* We pick the one-argument operator codes by default, so
12495                we don't have to change anything.  */
12496             ;
12497           else if (arity == 2)
12498             {
12499               /* If we thought this was a unary operator, we now know
12500                  it to be a binary operator.  */
12501               switch (operator_code)
12502                 {
12503                 case INDIRECT_REF:
12504                   operator_code = MULT_EXPR;
12505                   break;
12506
12507                 case ADDR_EXPR:
12508                   operator_code = BIT_AND_EXPR;
12509                   break;
12510
12511                 case CONVERT_EXPR:
12512                   operator_code = PLUS_EXPR;
12513                   break;
12514
12515                 case NEGATE_EXPR:
12516                   operator_code = MINUS_EXPR;
12517                   break;
12518
12519                 case PREINCREMENT_EXPR:
12520                   operator_code = POSTINCREMENT_EXPR;
12521                   break;
12522
12523                 case PREDECREMENT_EXPR:
12524                   operator_code = POSTDECREMENT_EXPR;
12525                   break;
12526
12527                 default:
12528                   my_friendly_abort (20000527);
12529                 }
12530
12531               SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12532
12533               if ((operator_code == POSTINCREMENT_EXPR
12534                    || operator_code == POSTDECREMENT_EXPR)
12535                   && ! processing_template_decl
12536                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12537                 {
12538                   if (methodp)
12539                     cp_error ("postfix `%D' must take `int' as its argument",
12540                               decl);
12541                   else
12542                     cp_error
12543                       ("postfix `%D' must take `int' as its second argument",
12544                        decl);
12545                 }
12546             }
12547           else
12548             {
12549               if (methodp)
12550                 cp_error ("`%D' must take either zero or one argument", decl);
12551               else
12552                 cp_error ("`%D' must take either one or two arguments", decl);
12553             }
12554
12555           /* More Effective C++ rule 6.  */
12556           if (warn_ecpp
12557               && (operator_code == POSTINCREMENT_EXPR
12558                   || operator_code == POSTDECREMENT_EXPR
12559                   || operator_code == PREINCREMENT_EXPR
12560                   || operator_code == PREDECREMENT_EXPR))
12561             {
12562               tree arg = TREE_VALUE (argtypes);
12563               tree ret = TREE_TYPE (TREE_TYPE (decl));
12564               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12565                 arg = TREE_TYPE (arg);
12566               arg = TYPE_MAIN_VARIANT (arg);
12567               if (operator_code == PREINCREMENT_EXPR
12568                   || operator_code == PREDECREMENT_EXPR)
12569                 {
12570                   if (TREE_CODE (ret) != REFERENCE_TYPE
12571                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12572                                        arg))
12573                     cp_warning ("prefix `%D' should return `%T'", decl,
12574                                 build_reference_type (arg));
12575                 }
12576               else
12577                 {
12578                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12579                     cp_warning ("postfix `%D' should return `%T'", decl, arg);
12580                 }
12581             }
12582         }
12583       else if (unary_op_p (operator_code))
12584         {
12585           if (arity != 1)
12586             {
12587               if (methodp)
12588                 cp_error ("`%D' must take `void'", decl);
12589               else
12590                 cp_error ("`%D' must take exactly one argument", decl);
12591             }
12592         }
12593       else /* if (binary_op_p (operator_code)) */
12594         {
12595           if (arity != 2)
12596             {
12597               if (methodp)
12598                 cp_error ("`%D' must take exactly one argument", decl);
12599               else
12600                 cp_error ("`%D' must take exactly two arguments", decl);
12601             }
12602
12603           /* More Effective C++ rule 7.  */
12604           if (warn_ecpp
12605               && (operator_code == TRUTH_ANDIF_EXPR
12606                   || operator_code == TRUTH_ORIF_EXPR
12607                   || operator_code == COMPOUND_EXPR))
12608             cp_warning ("user-defined `%D' always evaluates both arguments",
12609                         decl);
12610         }
12611
12612       /* Effective C++ rule 23.  */
12613       if (warn_ecpp
12614           && arity == 2
12615           && (operator_code == PLUS_EXPR
12616               || operator_code == MINUS_EXPR
12617               || operator_code == TRUNC_DIV_EXPR
12618               || operator_code == MULT_EXPR)
12619           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12620         cp_warning ("`%D' should return by value", decl);
12621
12622       /* 13.4.0.8 */
12623       for (; argtypes && argtypes != void_list_node;
12624           argtypes = TREE_CHAIN (argtypes))
12625         if (TREE_PURPOSE (argtypes))
12626           {
12627             TREE_PURPOSE (argtypes) = NULL_TREE;
12628             if (operator_code == POSTINCREMENT_EXPR
12629                 || operator_code == POSTDECREMENT_EXPR)
12630               {
12631                 if (pedantic)
12632                   cp_pedwarn ("`%D' cannot have default arguments", decl);
12633               }
12634             else
12635               cp_error ("`%D' cannot have default arguments", decl);
12636           }
12637
12638     }
12639 }
12640 \f
12641 static const char *
12642 tag_name (code)
12643      enum tag_types code;
12644 {
12645   switch (code)
12646     {
12647     case record_type:
12648       return "struct";
12649     case class_type:
12650       return "class";
12651     case union_type:
12652       return "union ";
12653     case enum_type:
12654       return "enum";
12655     default:
12656       my_friendly_abort (981122);
12657     }
12658 }
12659
12660 /* Get the struct, enum or union (CODE says which) with tag NAME.
12661    Define the tag as a forward-reference if it is not defined.
12662
12663    C++: If a class derivation is given, process it here, and report
12664    an error if multiple derivation declarations are not identical.
12665
12666    If this is a definition, come in through xref_tag and only look in
12667    the current frame for the name (since C++ allows new names in any
12668    scope.)  */
12669
12670 tree
12671 xref_tag (code_type_node, name, globalize)
12672      tree code_type_node;
12673      tree name;
12674      int globalize;
12675 {
12676   enum tag_types tag_code;
12677   enum tree_code code;
12678   register tree ref, t;
12679   struct binding_level *b = current_binding_level;
12680   int got_type = 0;
12681   tree attributes = NULL_TREE;
12682   tree context = NULL_TREE;
12683
12684   /* If we are called from the parser, code_type_node will sometimes be a
12685      TREE_LIST.  This indicates that the user wrote
12686      "class __attribute__ ((foo)) bar".  Extract the attributes so we can
12687      use them later.  */
12688   if (TREE_CODE (code_type_node) == TREE_LIST)
12689     {
12690       attributes = TREE_PURPOSE (code_type_node);
12691       code_type_node = TREE_VALUE (code_type_node);
12692     }
12693
12694   tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12695   switch (tag_code)
12696     {
12697     case record_type:
12698     case class_type:
12699       code = RECORD_TYPE;
12700       break;
12701     case union_type:
12702       code = UNION_TYPE;
12703       break;
12704     case enum_type:
12705       code = ENUMERAL_TYPE;
12706       break;
12707     default:
12708       my_friendly_abort (18);
12709     }
12710
12711   /* If a cross reference is requested, look up the type
12712      already defined for this tag and return it.  */
12713   if (TYPE_P (name))
12714     {
12715       t = name;
12716       name = TYPE_IDENTIFIER (t);
12717       got_type = 1;
12718     }
12719   else
12720     t = IDENTIFIER_TYPE_VALUE (name);
12721
12722   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12723       && TREE_CODE (t) != TEMPLATE_TEMPLATE_PARM)
12724     t = NULL_TREE;
12725
12726   if (! globalize)
12727     {
12728       /* If we know we are defining this tag, only look it up in
12729          this scope and don't try to find it as a type.  */
12730       ref = lookup_tag (code, name, b, 1);
12731     }
12732   else
12733     {
12734       if (t)
12735         {
12736           /* [dcl.type.elab] If the identifier resolves to a
12737              typedef-name or a template type-parameter, the
12738              elaborated-type-specifier is ill-formed.  */
12739           if (t != TYPE_MAIN_VARIANT (t)
12740               || (CLASS_TYPE_P (t) && TYPE_WAS_ANONYMOUS (t)))
12741             cp_pedwarn ("using typedef-name `%D' after `%s'",
12742                         TYPE_NAME (t), tag_name (tag_code));
12743           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12744             cp_error ("using template type parameter `%T' after `%s'",
12745                       t, tag_name (tag_code));
12746
12747           ref = t;
12748         }
12749       else
12750         ref = lookup_tag (code, name, b, 0);
12751
12752       if (! ref)
12753         {
12754           /* Try finding it as a type declaration.  If that wins,
12755              use it.  */
12756           ref = lookup_name (name, 1);
12757
12758           if (ref != NULL_TREE
12759               && processing_template_decl
12760               && DECL_CLASS_TEMPLATE_P (ref)
12761               && template_class_depth (current_class_type) == 0)
12762             /* Since GLOBALIZE is true, we're declaring a global
12763                template, so we want this type.  */
12764             ref = DECL_TEMPLATE_RESULT (ref);
12765
12766           if (ref && TREE_CODE (ref) == TYPE_DECL
12767               && TREE_CODE (TREE_TYPE (ref)) == code)
12768             ref = TREE_TYPE (ref);
12769           else
12770             ref = NULL_TREE;
12771         }
12772
12773       if (ref && current_class_type
12774           && template_class_depth (current_class_type)
12775           && PROCESSING_REAL_TEMPLATE_DECL_P ())
12776         {
12777           /* Since GLOBALIZE is non-zero, we are not looking at a
12778              definition of this tag.  Since, in addition, we are currently
12779              processing a (member) template declaration of a template
12780              class, we must be very careful; consider:
12781
12782                template <class X>
12783                struct S1
12784
12785                template <class U>
12786                struct S2
12787                { template <class V>
12788                friend struct S1; };
12789
12790              Here, the S2::S1 declaration should not be confused with the
12791              outer declaration.  In particular, the inner version should
12792              have a template parameter of level 2, not level 1.  This
12793              would be particularly important if the member declaration
12794              were instead:
12795
12796                template <class V = U> friend struct S1;
12797
12798              say, when we should tsubst into `U' when instantiating
12799              S2.  On the other hand, when presented with:
12800
12801                  template <class T>
12802                  struct S1 {
12803                    template <class U>
12804                    struct S2 {};
12805                    template <class U>
12806                    friend struct S2;
12807                  };
12808
12809               we must find the inner binding eventually.  We
12810               accomplish this by making sure that the new type we
12811               create to represent this declaration has the right
12812               TYPE_CONTEXT.  */
12813           context = TYPE_CONTEXT (ref);
12814           ref = NULL_TREE;
12815         }
12816     }
12817
12818   if (! ref)
12819     {
12820       /* If no such tag is yet defined, create a forward-reference node
12821          and record it as the "definition".
12822          When a real declaration of this type is found,
12823          the forward-reference will be altered into a real type.  */
12824       if (code == ENUMERAL_TYPE)
12825         {
12826           cp_error ("use of enum `%#D' without previous declaration", name);
12827
12828           ref = make_node (ENUMERAL_TYPE);
12829
12830           /* Give the type a default layout like unsigned int
12831              to avoid crashing if it does not get defined.  */
12832           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12833           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12834           TYPE_USER_ALIGN (ref) = 0;
12835           TREE_UNSIGNED (ref) = 1;
12836           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12837           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12838           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12839
12840           /* Enable us to recognize when a type is created in class context.
12841              To do nested classes correctly, this should probably be cleared
12842              out when we leave this classes scope.  Currently this in only
12843              done in `start_enum'.  */
12844
12845           pushtag (name, ref, globalize);
12846         }
12847       else
12848         {
12849           struct binding_level *old_b = class_binding_level;
12850
12851           ref = make_aggr_type (code);
12852           TYPE_CONTEXT (ref) = context;
12853
12854 #ifdef NONNESTED_CLASSES
12855           /* Class types don't nest the way enums do.  */
12856           class_binding_level = (struct binding_level *)0;
12857 #endif
12858           pushtag (name, ref, globalize);
12859           class_binding_level = old_b;
12860         }
12861     }
12862   else
12863     {
12864       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12865         redeclare_class_template (ref, current_template_parms);
12866     }
12867
12868   /* Until the type is defined, tentatively accept whatever
12869      structure tag the user hands us.  */
12870   if (!COMPLETE_TYPE_P (ref)
12871       && ref != current_class_type
12872       /* Have to check this, in case we have contradictory tag info.  */
12873       && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
12874     {
12875       if (tag_code == class_type)
12876         CLASSTYPE_DECLARED_CLASS (ref) = 1;
12877       else if (tag_code == record_type)
12878         CLASSTYPE_DECLARED_CLASS (ref) = 0;
12879     }
12880
12881   TREE_TYPE (ref) = attributes;
12882
12883   return ref;
12884 }
12885
12886 tree
12887 xref_tag_from_type (old, id, globalize)
12888      tree old, id;
12889      int globalize;
12890 {
12891   tree code_type_node;
12892
12893   if (TREE_CODE (old) == RECORD_TYPE)
12894     code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
12895                       ? class_type_node : record_type_node);
12896   else
12897     code_type_node = union_type_node;
12898
12899   if (id == NULL_TREE)
12900     id = TYPE_IDENTIFIER (old);
12901
12902   return xref_tag (code_type_node, id, globalize);
12903 }
12904
12905 /* REF is a type (named NAME), for which we have just seen some
12906    baseclasses.  BINFO is a list of those baseclasses; the
12907    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12908    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
12909    struct, or union.  */
12910
12911 void
12912 xref_basetypes (code_type_node, name, ref, binfo)
12913      tree code_type_node;
12914      tree name, ref;
12915      tree binfo;
12916 {
12917   /* In the declaration `A : X, Y, ... Z' we mark all the types
12918      (A, X, Y, ..., Z) so we can check for duplicates.  */
12919   tree binfos;
12920   tree base;
12921
12922   int i, len;
12923   enum tag_types tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12924
12925   if (tag_code == union_type)
12926     {
12927       cp_error ("derived union `%T' invalid", ref);
12928       return;
12929     }
12930
12931   len = list_length (binfo);
12932
12933   /* First, make sure that any templates in base-classes are
12934      instantiated.  This ensures that if we call ourselves recursively
12935      we do not get confused about which classes are marked and which
12936      are not.  */
12937   for (base = binfo; base; base = TREE_CHAIN (base))
12938     complete_type (TREE_VALUE (base));
12939
12940   SET_CLASSTYPE_MARKED (ref);
12941   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
12942
12943   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
12944     {
12945       /* The base of a derived struct is public by default.  */
12946       int via_public
12947         = (TREE_PURPOSE (binfo) == access_public_node
12948            || TREE_PURPOSE (binfo) == access_public_virtual_node
12949            || (tag_code != class_type
12950                && (TREE_PURPOSE (binfo) == access_default_node
12951                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
12952       int via_protected
12953         = (TREE_PURPOSE (binfo) == access_protected_node
12954            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
12955       int via_virtual
12956         = (TREE_PURPOSE (binfo) == access_private_virtual_node
12957            || TREE_PURPOSE (binfo) == access_protected_virtual_node
12958            || TREE_PURPOSE (binfo) == access_public_virtual_node
12959            || TREE_PURPOSE (binfo) == access_default_virtual_node);
12960       tree basetype = TREE_VALUE (binfo);
12961       tree base_binfo;
12962
12963       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
12964         basetype = TREE_TYPE (basetype);
12965       if (!basetype
12966           || (TREE_CODE (basetype) != RECORD_TYPE
12967               && TREE_CODE (basetype) != TYPENAME_TYPE
12968               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
12969               && TREE_CODE (basetype) != TEMPLATE_TEMPLATE_PARM))
12970         {
12971           cp_error ("base type `%T' fails to be a struct or class type",
12972                     TREE_VALUE (binfo));
12973           continue;
12974         }
12975
12976       GNU_xref_hier (name, basetype, via_public, via_virtual, 0);
12977
12978       /* This code replaces similar code in layout_basetypes.
12979          We put the complete_type first for implicit `typename'.  */
12980       if (!COMPLETE_TYPE_P (basetype)
12981           && ! (current_template_parms && uses_template_parms (basetype)))
12982         {
12983           cp_error ("base class `%T' has incomplete type", basetype);
12984           continue;
12985         }
12986       else
12987         {
12988           if (CLASSTYPE_MARKED (basetype))
12989             {
12990               if (basetype == ref)
12991                 cp_error ("recursive type `%T' undefined", basetype);
12992               else
12993                 cp_error ("duplicate base type `%T' invalid", basetype);
12994               continue;
12995             }
12996
12997           if (TYPE_FOR_JAVA (basetype)
12998               && (current_lang_stack
12999                   == &VARRAY_TREE (current_lang_base, 0)))
13000             TYPE_FOR_JAVA (ref) = 1;
13001
13002           /* Note that the BINFO records which describe individual
13003              inheritances are *not* shared in the lattice!  They
13004              cannot be shared because a given baseclass may be
13005              inherited with different `accessibility' by different
13006              derived classes.  (Each BINFO record describing an
13007              individual inheritance contains flags which say what
13008              the `accessibility' of that particular inheritance is.)  */
13009
13010           base_binfo
13011             = make_binfo (size_zero_node, basetype,
13012                           CLASS_TYPE_P (basetype)
13013                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
13014                           CLASS_TYPE_P (basetype)
13015                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
13016
13017           TREE_VEC_ELT (binfos, i) = base_binfo;
13018           TREE_VIA_PUBLIC (base_binfo) = via_public;
13019           TREE_VIA_PROTECTED (base_binfo) = via_protected;
13020           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
13021           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
13022
13023           /* We need to unshare the binfos now so that lookups during class
13024              definition work.  */
13025           unshare_base_binfos (base_binfo);
13026
13027           SET_CLASSTYPE_MARKED (basetype);
13028
13029           /* We are free to modify these bits because they are meaningless
13030              at top level, and BASETYPE is a top-level type.  */
13031           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
13032             {
13033               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
13034               /* Converting to a virtual base class requires looking
13035                  up the offset of the virtual base.  */
13036               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13037             }
13038
13039           if (CLASS_TYPE_P (basetype))
13040             {
13041               TYPE_HAS_NEW_OPERATOR (ref)
13042                 |= TYPE_HAS_NEW_OPERATOR (basetype);
13043               TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
13044                 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
13045               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
13046               /* If the base-class uses multiple inheritance, so do we.  */
13047               TYPE_USES_MULTIPLE_INHERITANCE (ref)
13048                 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
13049               /* Likewise, if converting to a base of the base may require
13050                  code, then we may need to generate code to convert to a
13051                  base as well.  */
13052               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
13053                 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
13054             }
13055
13056           i += 1;
13057         }
13058     }
13059   if (i)
13060     TREE_VEC_LENGTH (binfos) = i;
13061   else
13062     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
13063
13064   if (i > 1)
13065     {
13066       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
13067       /* If there is more than one non-empty they cannot be at the same
13068          address.  */
13069       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13070     }
13071
13072   /* Unmark all the types.  */
13073   while (--i >= 0)
13074     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
13075   CLEAR_CLASSTYPE_MARKED (ref);
13076
13077   /* Now that we know all the base-classes, set up the list of virtual
13078      bases.  */
13079   get_vbase_types (ref);
13080 }
13081
13082 \f
13083 /* Begin compiling the definition of an enumeration type.
13084    NAME is its name (or null if anonymous).
13085    Returns the type object, as yet incomplete.
13086    Also records info about it so that build_enumerator
13087    may be used to declare the individual values as they are read.  */
13088
13089 tree
13090 start_enum (name)
13091      tree name;
13092 {
13093   register tree enumtype = NULL_TREE;
13094   struct binding_level *b = current_binding_level;
13095
13096   /* If this is the real definition for a previous forward reference,
13097      fill in the contents in the same object that used to be the
13098      forward reference.  */
13099
13100   if (name != NULL_TREE)
13101     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
13102
13103   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
13104     {
13105       cp_error ("multiple definition of `%#T'", enumtype);
13106       cp_error_at ("previous definition here", enumtype);
13107       /* Clear out TYPE_VALUES, and start again.  */
13108       TYPE_VALUES (enumtype) = NULL_TREE;
13109     }
13110   else
13111     {
13112       enumtype = make_node (ENUMERAL_TYPE);
13113       pushtag (name, enumtype, 0);
13114     }
13115
13116   if (current_class_type)
13117     TREE_ADDRESSABLE (b->tags) = 1;
13118
13119   GNU_xref_decl (current_function_decl, enumtype);
13120   return enumtype;
13121 }
13122
13123 /* After processing and defining all the values of an enumeration type,
13124    install their decls in the enumeration type and finish it off.
13125    ENUMTYPE is the type object and VALUES a list of name-value pairs.
13126    Returns ENUMTYPE.  */
13127
13128 tree
13129 finish_enum (enumtype)
13130      tree enumtype;
13131 {
13132   register tree minnode = NULL_TREE, maxnode = NULL_TREE;
13133   /* Calculate the maximum value of any enumerator in this type.  */
13134
13135   tree values = TYPE_VALUES (enumtype);
13136   if (values)
13137     {
13138       tree pair;
13139
13140       for (pair = values; pair; pair = TREE_CHAIN (pair))
13141         {
13142           tree decl;
13143           tree value;
13144
13145           /* The TREE_VALUE is a CONST_DECL for this enumeration
13146              constant.  */
13147           decl = TREE_VALUE (pair);
13148
13149           /* [dcl.enum]
13150
13151              Following the closing brace of an enum-specifier, each
13152              enumerator has the type of its enumeration.  Prior to the
13153              closing brace, the type of each enumerator is the type of
13154              its initializing value.  */
13155           TREE_TYPE (decl) = enumtype;
13156
13157           /* The DECL_INITIAL will be NULL if we are processing a
13158              template declaration and this enumeration constant had no
13159              explicit initializer.  */
13160           value = DECL_INITIAL (decl);
13161           if (value && !processing_template_decl)
13162             {
13163               /* Set the TREE_TYPE for the VALUE as well.  That's so
13164                  that when we call decl_constant_value we get an
13165                  entity of the right type (but with the constant
13166                  value).  Since we shouldn't ever call
13167                  decl_constant_value on a template type, there's no
13168                  reason to do that when processing_template_decl.
13169                  And, if the expression is something like a
13170                  TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will
13171                  wreak havoc on the intended type of the expression.
13172
13173                  Of course, there's also no point in trying to compute
13174                  minimum or maximum values if we're in a template.  */
13175               TREE_TYPE (value) = enumtype;
13176
13177               if (!minnode)
13178                 minnode = maxnode = value;
13179               else if (tree_int_cst_lt (maxnode, value))
13180                 maxnode = value;
13181               else if (tree_int_cst_lt (value, minnode))
13182                 minnode = value;
13183             }
13184
13185           if (processing_template_decl)
13186             /* If this is just a template, leave the CONST_DECL
13187                alone.  That way tsubst_copy will find CONST_DECLs for
13188                CONST_DECLs, and not INTEGER_CSTs.  */
13189             ;
13190           else
13191             /* In the list we're building up, we want the enumeration
13192                values, not the CONST_DECLs.  */
13193             TREE_VALUE (pair) = value;
13194         }
13195     }
13196   else
13197     maxnode = minnode = integer_zero_node;
13198
13199   TYPE_VALUES (enumtype) = nreverse (values);
13200
13201   if (processing_template_decl)
13202     {
13203       tree scope = current_scope ();
13204       if (scope && TREE_CODE (scope) == FUNCTION_DECL)
13205         add_tree (build_min (TAG_DEFN, enumtype));
13206     }
13207   else
13208     {
13209       int unsignedp = tree_int_cst_sgn (minnode) >= 0;
13210       int lowprec = min_precision (minnode, unsignedp);
13211       int highprec = min_precision (maxnode, unsignedp);
13212       int precision = MAX (lowprec, highprec);
13213       tree tem;
13214
13215       TYPE_SIZE (enumtype) = NULL_TREE;
13216
13217       /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
13218
13219       TYPE_PRECISION (enumtype) = precision;
13220       if (unsignedp)
13221         fixup_unsigned_type (enumtype);
13222       else
13223         fixup_signed_type (enumtype);
13224
13225       if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
13226         /* Use the width of the narrowest normal C type which is wide
13227            enough.  */
13228         TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
13229                                                     (precision, 1));
13230       else
13231         TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
13232
13233       TYPE_SIZE (enumtype) = 0;
13234       layout_type (enumtype);
13235
13236       /* Fix up all variant types of this enum type.  */
13237       for (tem = TYPE_MAIN_VARIANT (enumtype); tem;
13238            tem = TYPE_NEXT_VARIANT (tem))
13239         {
13240           TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
13241           TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
13242           TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
13243           TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
13244           TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
13245           TYPE_MODE (tem) = TYPE_MODE (enumtype);
13246           TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
13247           TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
13248           TYPE_USER_ALIGN (tem) = TYPE_USER_ALIGN (enumtype);
13249           TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
13250         }
13251
13252       /* Finish debugging output for this type.  */
13253       rest_of_type_compilation (enumtype, namespace_bindings_p ());
13254     }
13255
13256   return enumtype;
13257 }
13258
13259 /* Build and install a CONST_DECL for an enumeration constant of the
13260    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13261    Assignment of sequential values by default is handled here.  */
13262
13263 void
13264 build_enumerator (name, value, enumtype)
13265      tree name;
13266      tree value;
13267      tree enumtype;
13268 {
13269   tree decl;
13270   tree context;
13271   tree type;
13272   tree values;
13273
13274   /* Remove no-op casts from the value.  */
13275   if (value)
13276     STRIP_TYPE_NOPS (value);
13277
13278   if (! processing_template_decl)
13279     {
13280       /* Validate and default VALUE.  */
13281       if (value != NULL_TREE)
13282         {
13283           value = decl_constant_value (value);
13284
13285           if (TREE_CODE (value) == INTEGER_CST)
13286             {
13287               value = default_conversion (value);
13288               constant_expression_warning (value);
13289             }
13290           else
13291             {
13292               cp_error ("enumerator value for `%D' not integer constant", name);
13293               value = NULL_TREE;
13294             }
13295         }
13296
13297       /* Default based on previous value.  */
13298       if (value == NULL_TREE && ! processing_template_decl)
13299         {
13300           tree prev_value;
13301
13302           if (TYPE_VALUES (enumtype))
13303             {
13304               /* The next value is the previous value ... */
13305               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
13306               /* ... plus one.  */
13307               value = cp_build_binary_op (PLUS_EXPR,
13308                                           prev_value,
13309                                           integer_one_node);
13310
13311               if (tree_int_cst_lt (value, prev_value))
13312                 cp_error ("overflow in enumeration values at `%D'", name);
13313             }
13314           else
13315             value = integer_zero_node;
13316         }
13317
13318       /* Remove no-op casts from the value.  */
13319       if (value)
13320         STRIP_TYPE_NOPS (value);
13321 #if 0
13322       /* To fix MAX_VAL enum consts. (bkoz)  */
13323       TREE_TYPE (value) = integer_type_node;
13324 #endif
13325     }
13326
13327   /* We always have to copy here; not all INTEGER_CSTs are unshared.
13328      Even in other cases, we will later (in finish_enum) be setting
13329      the type of VALUE.  But, we don't need to make a copy if this
13330      VALUE is one of the enumeration constants for this same
13331      enumeration type.  */
13332   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
13333     if (TREE_VALUE (values) == value)
13334       break;
13335   /* If we didn't break out of the loop, then we do need a copy.  */
13336   if (!values && value)
13337     value = copy_node (value);
13338
13339   /* C++ associates enums with global, function, or class declarations.  */
13340   context = current_scope ();
13341
13342   /* Build the actual enumeration constant.  Note that the enumeration
13343     constants have the type of their initializers until the
13344     enumeration is complete:
13345
13346       [ dcl.enum ]
13347
13348       Following the closing brace of an enum-specifier, each enumer-
13349       ator has the type of its enumeration.  Prior to the closing
13350       brace, the type of each enumerator is the type of its
13351       initializing value.
13352
13353     In finish_enum we will reset the type.  Of course, if we're
13354     processing a template, there may be no value.   */
13355   type = value ? TREE_TYPE (value) : NULL_TREE;
13356
13357   if (context && context == current_class_type)
13358     /* This enum declaration is local to the class.  We need the full
13359       lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
13360     decl = build_lang_decl (CONST_DECL, name, type);
13361   else
13362     /* It's a global enum, or it's local to a function.  (Note local to
13363       a function could mean local to a class method.  */
13364     decl = build_decl (CONST_DECL, name, type);
13365
13366   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
13367   DECL_INITIAL (decl) = value;
13368   TREE_READONLY (decl) = 1;
13369
13370   if (context && context == current_class_type)
13371     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13372       on the TYPE_FIELDS list for `S'.  (That's so that you can say
13373       things like `S::i' later.)  */
13374     finish_member_declaration (decl);
13375   else
13376     {
13377       pushdecl (decl);
13378       GNU_xref_decl (current_function_decl, decl);
13379     }
13380
13381   /* Add this enumeration constant to the list for this type.  */
13382   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13383 }
13384
13385 \f
13386 /* We're defining DECL.  Make sure that it's type is OK.  */
13387
13388 static void
13389 check_function_type (decl)
13390      tree decl;
13391 {
13392   tree fntype = TREE_TYPE (decl);
13393   tree return_type = complete_type (TREE_TYPE (fntype));
13394
13395   /* In a function definition, arg types must be complete.  */
13396   require_complete_types_for_parms (current_function_parms);
13397
13398   if (!COMPLETE_OR_VOID_TYPE_P (return_type))
13399     {
13400       cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
13401
13402       /* Make it return void instead, but don't change the
13403          type of the DECL_RESULT, in case we have a named return value.  */
13404       if (TREE_CODE (fntype) == METHOD_TYPE)
13405         {
13406           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
13407           TREE_TYPE (decl)
13408             = build_cplus_method_type (ctype,
13409                                        void_type_node,
13410                                        FUNCTION_ARG_CHAIN (decl));
13411         }
13412       else
13413         TREE_TYPE (decl)
13414           = build_function_type (void_type_node,
13415                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
13416       TREE_TYPE (decl)
13417         = build_exception_variant (fntype,
13418                                    TYPE_RAISES_EXCEPTIONS (fntype));
13419     }
13420   else
13421     abstract_virtuals_error (decl, TREE_TYPE (fntype));
13422 }
13423
13424 /* Create the FUNCTION_DECL for a function definition.
13425    DECLSPECS and DECLARATOR are the parts of the declaration;
13426    they describe the function's name and the type it returns,
13427    but twisted together in a fashion that parallels the syntax of C.
13428
13429    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13430    DECLARATOR is really the DECL for the function we are about to
13431    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13432    indicating that the function is an inline defined in-class, and
13433    SF_EXPAND indicating that we should generate RTL for this
13434    function.
13435
13436    This function creates a binding context for the function body
13437    as well as setting up the FUNCTION_DECL in current_function_decl.
13438
13439    Returns 1 on success.  If the DECLARATOR is not suitable for a function
13440    (it defines a datum instead), we return 0, which tells
13441    yyparse to report a parse error.
13442
13443    For C++, we must first check whether that datum makes any sense.
13444    For example, "class A local_a(1,2);" means that variable local_a
13445    is an aggregate of type A, which should have a constructor
13446    applied to it with the argument list [1, 2].  */
13447
13448 int
13449 start_function (declspecs, declarator, attrs, flags)
13450      tree declspecs, declarator, attrs;
13451      int flags;
13452 {
13453   tree decl1;
13454   tree ctype = NULL_TREE;
13455   tree fntype;
13456   tree restype;
13457   extern int have_extern_spec;
13458   extern int used_extern_spec;
13459   int doing_friend = 0;
13460   struct binding_level *bl;
13461
13462   /* Sanity check.  */
13463   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
13464   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
13465
13466   /* This should only be done once on the top most decl.  */
13467   if (have_extern_spec && !used_extern_spec)
13468     {
13469       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
13470       used_extern_spec = 1;
13471     }
13472
13473   if (flags & SF_PRE_PARSED)
13474     {
13475       decl1 = declarator;
13476
13477       fntype = TREE_TYPE (decl1);
13478       if (TREE_CODE (fntype) == METHOD_TYPE)
13479         ctype = TYPE_METHOD_BASETYPE (fntype);
13480
13481       /* ISO C++ 11.4/5.  A friend function defined in a class is in
13482          the (lexical) scope of the class in which it is defined.  */
13483       if (!ctype && DECL_FRIEND_P (decl1))
13484         {
13485           ctype = DECL_FRIEND_CONTEXT (decl1);
13486
13487           /* CTYPE could be null here if we're dealing with a template;
13488              for example, `inline friend float foo()' inside a template
13489              will have no CTYPE set.  */
13490           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13491             ctype = NULL_TREE;
13492           else
13493             doing_friend = 1;
13494         }
13495
13496       last_function_parms = DECL_ARGUMENTS (decl1);
13497       last_function_parm_tags = NULL_TREE;
13498     }
13499   else
13500     {
13501       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL_TREE);
13502       /* If the declarator is not suitable for a function definition,
13503          cause a syntax error.  */
13504       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
13505
13506       fntype = TREE_TYPE (decl1);
13507
13508       restype = TREE_TYPE (fntype);
13509       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13510         {
13511           cp_error ("semicolon missing after declaration of `%#T'", restype);
13512           shadow_tag (build_tree_list (NULL_TREE, restype));
13513           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13514           if (TREE_CODE (fntype) == FUNCTION_TYPE)
13515             fntype = build_function_type (integer_type_node,
13516                                           TYPE_ARG_TYPES (fntype));
13517           else
13518             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13519                                               integer_type_node,
13520                                               TYPE_ARG_TYPES (fntype));
13521           TREE_TYPE (decl1) = fntype;
13522         }
13523
13524       if (TREE_CODE (fntype) == METHOD_TYPE)
13525         ctype = TYPE_METHOD_BASETYPE (fntype);
13526       else if (DECL_MAIN_P (decl1))
13527         {
13528           /* If this doesn't return integer_type, complain.  */
13529           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13530             {
13531               if (pedantic || warn_return_type)
13532                 pedwarn ("return type for `main' changed to `int'");
13533               TREE_TYPE (decl1) = fntype = default_function_type;
13534             }
13535         }
13536     }
13537
13538   /* Sometimes we don't notice that a function is a static member, and
13539      build a METHOD_TYPE for it.  Fix that up now.  */
13540   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13541       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13542     {
13543       revert_static_member_fn (decl1);
13544       last_function_parms = TREE_CHAIN (last_function_parms);
13545       ctype = NULL_TREE;
13546     }
13547
13548   /* Warn if function was previously implicitly declared
13549      (but not if we warned then).  */
13550   if (! warn_implicit
13551       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13552     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13553
13554   /* Set up current_class_type, and enter the scope of the class, if
13555      appropriate.  */
13556   if (ctype)
13557     push_nested_class (ctype, 1);
13558   else if (DECL_STATIC_FUNCTION_P (decl1))
13559     push_nested_class (DECL_CONTEXT (decl1), 2);
13560
13561   /* Now that we have entered the scope of the class, we must restore
13562      the bindings for any template parameters surrounding DECL1, if it
13563      is an inline member template.  (Order is important; consider the
13564      case where a template parameter has the same name as a field of
13565      the class.)  It is not until after this point that
13566      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
13567   if (flags & SF_INCLASS_INLINE)
13568     maybe_begin_member_template_processing (decl1);
13569
13570   /* Effective C++ rule 15.  See also c_expand_return.  */
13571   if (warn_ecpp
13572       && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
13573       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13574     cp_warning ("`operator=' should return a reference to `*this'");
13575
13576   /* Make the init_value nonzero so pushdecl knows this is not tentative.
13577      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
13578   if (!DECL_INITIAL (decl1))
13579     DECL_INITIAL (decl1) = error_mark_node;
13580
13581 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
13582   SET_DEFAULT_DECL_ATTRIBUTES (decl1, attrs);
13583 #endif
13584
13585   /* This function exists in static storage.
13586      (This does not mean `static' in the C sense!)  */
13587   TREE_STATIC (decl1) = 1;
13588
13589   /* We must call push_template_decl after current_class_type is set
13590      up.  (If we are processing inline definitions after exiting a
13591      class scope, current_class_type will be NULL_TREE until set above
13592      by push_nested_class.)  */
13593   if (processing_template_decl)
13594     decl1 = push_template_decl (decl1);
13595
13596   /* We are now in the scope of the function being defined.  */
13597   current_function_decl = decl1;
13598
13599   /* Save the parm names or decls from this function's declarator
13600      where store_parm_decls will find them.  */
13601   current_function_parms = last_function_parms;
13602   current_function_parm_tags = last_function_parm_tags;
13603
13604   /* Make sure the parameter and return types are reasonable.  When
13605      you declare a function, these types can be incomplete, but they
13606      must be complete when you define the function.  */
13607   if (! processing_template_decl)
13608     check_function_type (decl1);
13609
13610   /* Build the return declaration for the function.  */
13611   restype = TREE_TYPE (fntype);
13612   if (!processing_template_decl)
13613     {
13614       if (!DECL_RESULT (decl1))
13615         {
13616           DECL_RESULT (decl1)
13617             = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13618           c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype),
13619                                       DECL_RESULT (decl1));
13620         }
13621     }
13622   else
13623     /* Just use `void'.  Nobody will ever look at this anyhow.  */
13624     DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, void_type_node);
13625
13626   /* Initialize RTL machinery.  We cannot do this until
13627      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
13628      even when processing a template; this is how we get
13629      CFUN set up, and our per-function variables initialized.  */
13630   bl = current_binding_level;
13631   init_function_start (decl1, input_filename, lineno);
13632   current_binding_level = bl;
13633   expanding_p = (flags & SF_EXPAND) != 0;
13634
13635   /* Even though we're inside a function body, we still don't want to
13636      call expand_expr to calculate the size of a variable-sized array.
13637      We haven't necessarily assigned RTL to all variables yet, so it's
13638      not safe to try to expand expressions involving them.  */
13639   immediate_size_expand = 0;
13640   cfun->x_dont_save_pending_sizes_p = 1;
13641
13642   /* If we're building a statement-tree, start the tree now.  */
13643   if (processing_template_decl || !expanding_p)
13644     begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13645
13646   /* Let the user know we're compiling this function.  */
13647   announce_function (decl1);
13648
13649   /* Record the decl so that the function name is defined.
13650      If we already have a decl for this name, and it is a FUNCTION_DECL,
13651      use the old decl.  */
13652   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13653     {
13654       /* A specialization is not used to guide overload resolution.  */
13655       if (!DECL_TEMPLATE_SPECIALIZATION (decl1)
13656           && ! DECL_FUNCTION_MEMBER_P (decl1))
13657         decl1 = pushdecl (decl1);
13658       else
13659         {
13660           /* We need to set the DECL_CONTEXT. */
13661           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13662             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13663           /* And make sure we have enough default args.  */
13664           check_default_args (decl1);
13665         }
13666       fntype = TREE_TYPE (decl1);
13667     }
13668
13669   /* Reset these in case the call to pushdecl changed them.  */
13670   current_function_decl = decl1;
13671   cfun->decl = decl1;
13672
13673   /* Initialize the per-function data.  */
13674   if (!DECL_PENDING_INLINE_P (decl1) && DECL_SAVED_FUNCTION_DATA (decl1))
13675     {
13676       /* If we already parsed this function, and we're just expanding it
13677          now, restore saved state.  */
13678       struct binding_level *bl = current_binding_level;
13679       *cp_function_chain = *DECL_SAVED_FUNCTION_DATA (decl1);
13680       current_binding_level = bl;
13681
13682       /* This function is being processed in whole-function mode; we
13683          already did semantic analysis.  */
13684       cfun->x_whole_function_mode_p = 1;
13685
13686       /* If we decided that we didn't want to inline this function,
13687          make sure the back-end knows that.  */
13688       if (!current_function_cannot_inline)
13689         current_function_cannot_inline = cp_function_chain->cannot_inline;
13690
13691       /* We don't need the saved data anymore.  */
13692       free (DECL_SAVED_FUNCTION_DATA (decl1));
13693       DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13694     }
13695   else if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13696     {
13697       /* We know that this was set up by `grokclassfn'.  We do not
13698          wait until `store_parm_decls', since evil parse errors may
13699          never get us to that point.  Here we keep the consistency
13700          between `current_class_type' and `current_class_ptr'.  */
13701       tree t = DECL_ARGUMENTS (decl1);
13702
13703       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13704                           162);
13705       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13706                           19990811);
13707
13708       cp_function_chain->x_current_class_ref
13709         = build_indirect_ref (t, NULL_PTR);
13710       cp_function_chain->x_current_class_ptr = t;
13711
13712       /* Constructors and destructors need to know whether they're "in
13713          charge" of initializing virtual base classes.  */
13714       if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
13715         current_in_charge_parm = TREE_CHAIN (t);
13716     }
13717
13718   if (DECL_INTERFACE_KNOWN (decl1))
13719     {
13720       tree ctx = decl_function_context (decl1);
13721
13722       if (DECL_NOT_REALLY_EXTERN (decl1))
13723         DECL_EXTERNAL (decl1) = 0;
13724
13725       if (ctx != NULL_TREE && DECL_THIS_INLINE (ctx)
13726           && TREE_PUBLIC (ctx))
13727         /* This is a function in a local class in an extern inline
13728            function.  */
13729         comdat_linkage (decl1);
13730     }
13731   /* If this function belongs to an interface, it is public.
13732      If it belongs to someone else's interface, it is also external.
13733      This only affects inlines and template instantiations.  */
13734   else if (interface_unknown == 0
13735            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13736                || flag_alt_external_templates))
13737     {
13738       if (DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1)
13739           || processing_template_decl)
13740         {
13741           DECL_EXTERNAL (decl1)
13742             = (interface_only
13743                || (DECL_THIS_INLINE (decl1) && ! flag_implement_inlines
13744                    && !DECL_VINDEX (decl1)));
13745
13746           /* For WIN32 we also want to put these in linkonce sections.  */
13747           maybe_make_one_only (decl1);
13748         }
13749       else
13750         DECL_EXTERNAL (decl1) = 0;
13751       DECL_NOT_REALLY_EXTERN (decl1) = 0;
13752       DECL_INTERFACE_KNOWN (decl1) = 1;
13753     }
13754   else if (interface_unknown && interface_only
13755            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13756                || flag_alt_external_templates))
13757     {
13758       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13759          interface, we will have interface_only set but not
13760          interface_known.  In that case, we don't want to use the normal
13761          heuristics because someone will supply a #pragma implementation
13762          elsewhere, and deducing it here would produce a conflict.  */
13763       comdat_linkage (decl1);
13764       DECL_EXTERNAL (decl1) = 0;
13765       DECL_INTERFACE_KNOWN (decl1) = 1;
13766       DECL_DEFER_OUTPUT (decl1) = 1;
13767     }
13768   else
13769     {
13770       /* This is a definition, not a reference.
13771          So clear DECL_EXTERNAL.  */
13772       DECL_EXTERNAL (decl1) = 0;
13773
13774       if ((DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1))
13775           && ! DECL_INTERFACE_KNOWN (decl1)
13776           /* Don't try to defer nested functions for now.  */
13777           && ! decl_function_context (decl1))
13778         DECL_DEFER_OUTPUT (decl1) = 1;
13779       else
13780         DECL_INTERFACE_KNOWN (decl1) = 1;
13781     }
13782
13783   if (doing_semantic_analysis_p ())
13784     {
13785       pushlevel (0);
13786       current_binding_level->parm_flag = 1;
13787     }
13788
13789   if (attrs)
13790     cplus_decl_attributes (decl1, NULL_TREE, attrs);
13791
13792   if (!building_stmt_tree ())
13793     {
13794       GNU_xref_function (decl1, current_function_parms);
13795       make_function_rtl (decl1);
13796     }
13797
13798   /* Promote the value to int before returning it.  */
13799   if (C_PROMOTING_INTEGER_TYPE_P (restype))
13800     restype = type_promotes_to (restype);
13801
13802   /* If this fcn was already referenced via a block-scope `extern' decl
13803      (or an implicit decl), propagate certain information about the usage.  */
13804   if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1)))
13805     TREE_ADDRESSABLE (decl1) = 1;
13806
13807   if (DECL_RESULT (decl1) == NULL_TREE)
13808     {
13809       DECL_RESULT (decl1)
13810         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13811       TREE_READONLY (DECL_RESULT (decl1)) = CP_TYPE_CONST_P (restype);
13812       TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = CP_TYPE_VOLATILE_P (restype);
13813     }
13814
13815   ++function_depth;
13816
13817   if (DECL_DESTRUCTOR_P (decl1))
13818     {
13819       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13820       DECL_CONTEXT (dtor_label) = current_function_decl;
13821     }
13822   /* Under the old ABI we return `this' from constructors, so we make
13823      ordinary `return' statements in constructors jump to CTOR_LABEL;
13824      from there we return `this'.  Under the new ABI, we don't bother
13825      with any of this.  By not setting CTOR_LABEL the remainder of the
13826      machinery is automatically disabled.  */
13827   else if (!flag_new_abi && DECL_CONSTRUCTOR_P (decl1))
13828     {
13829       ctor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13830       DECL_CONTEXT (ctor_label) = current_function_decl;
13831     }
13832
13833   return 1;
13834 }
13835 \f
13836 /* Called after store_parm_decls for a function-try-block.  */
13837
13838 void
13839 expand_start_early_try_stmts ()
13840 {
13841   expand_start_try_stmts ();
13842 }
13843
13844 /* Store the parameter declarations into the current function declaration.
13845    This is called after parsing the parameter declarations, before
13846    digesting the body of the function.
13847
13848    Also install to binding contour return value identifier, if any.  */
13849
13850 void
13851 store_parm_decls ()
13852 {
13853   register tree fndecl = current_function_decl;
13854   register tree parm;
13855   int parms_have_cleanups = 0;
13856   tree cleanups = NULL_TREE;
13857
13858   /* This is a list of types declared among parms in a prototype.  */
13859   tree parmtags = current_function_parm_tags;
13860
13861   /* This is a chain of any other decls that came in among the parm
13862      declarations.  If a parm is declared with  enum {foo, bar} x;
13863      then CONST_DECLs for foo and bar are put here.  */
13864   tree nonparms = NULL_TREE;
13865
13866   /* Create a binding level for the parms.  */
13867   if (!building_stmt_tree ())
13868     expand_start_bindings (2);
13869
13870   if (current_function_parms)
13871     {
13872       /* This case is when the function was defined with an ANSI prototype.
13873          The parms already have decls, so we need not do anything here
13874          except record them as in effect
13875          and complain if any redundant old-style parm decls were written.  */
13876
13877       tree specparms = current_function_parms;
13878       tree next;
13879
13880       if (doing_semantic_analysis_p ())
13881         {
13882           /* Must clear this because it might contain TYPE_DECLs declared
13883              at class level.  */
13884           storedecls (NULL_TREE);
13885
13886           /* If we're doing semantic analysis, then we'll call pushdecl
13887              for each of these.  We must do them in reverse order so that
13888              they end in the correct forward order.  */
13889           specparms = nreverse (specparms);
13890         }
13891
13892       for (parm = specparms; parm; parm = next)
13893         {
13894           next = TREE_CHAIN (parm);
13895           if (TREE_CODE (parm) == PARM_DECL)
13896             {
13897               tree type = TREE_TYPE (parm);
13898
13899               if (doing_semantic_analysis_p ())
13900                 {
13901                   tree cleanup;
13902
13903                   if (DECL_NAME (parm) == NULL_TREE
13904                       || TREE_CODE (parm) != VOID_TYPE)
13905                     pushdecl (parm);
13906                   else
13907                     cp_error ("parameter `%D' declared void", parm);
13908
13909                   cleanup = (processing_template_decl
13910                              ? NULL_TREE
13911                              : maybe_build_cleanup (parm));
13912
13913                   if (cleanup)
13914                     cleanups = tree_cons (parm, cleanup, cleanups);
13915                 }
13916               else if (type != error_mark_node
13917                        && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
13918                 parms_have_cleanups = 1;
13919             }
13920           else
13921             {
13922               /* If we find an enum constant or a type tag,
13923                  put it aside for the moment.  */
13924               TREE_CHAIN (parm) = NULL_TREE;
13925               nonparms = chainon (nonparms, parm);
13926             }
13927         }
13928
13929       if (doing_semantic_analysis_p ())
13930         {
13931           /* Get the decls in their original chain order
13932              and record in the function.  This is all and only the
13933              PARM_DECLs that were pushed into scope by the loop above.  */
13934           DECL_ARGUMENTS (fndecl) = getdecls ();
13935           storetags (chainon (parmtags, gettags ()));
13936         }
13937     }
13938   else
13939     DECL_ARGUMENTS (fndecl) = NULL_TREE;
13940
13941   /* Now store the final chain of decls for the arguments
13942      as the decl-chain of the current lexical scope.
13943      Put the enumerators in as well, at the front so that
13944      DECL_ARGUMENTS is not modified.  */
13945   if (doing_semantic_analysis_p ())
13946     storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
13947
13948   /* Initialize the RTL code for the function.  */
13949   DECL_SAVED_INSNS (fndecl) = 0;
13950   if (! building_stmt_tree ())
13951     expand_function_start (fndecl, parms_have_cleanups);
13952
13953   current_function_parms_stored = 1;
13954
13955   /* If this function is `main', emit a call to `__main'
13956      to run global initializers, etc.  */
13957   if (DECL_MAIN_P (fndecl) && !building_stmt_tree ())
13958     expand_main_function ();
13959
13960   /* Now that we have initialized the parms, we can start their
13961      cleanups.  We cannot do this before, since expand_decl_cleanup
13962      should not be called before the parm can be used.  */
13963   while (cleanups)
13964     {
13965       finish_decl_cleanup (TREE_PURPOSE (cleanups),
13966                            TREE_VALUE (cleanups));
13967       cleanups = TREE_CHAIN (cleanups);
13968     }
13969
13970   /* Create a binding contour which can be used to catch
13971      cleanup-generated temporaries.  Also, if the return value needs or
13972      has initialization, deal with that now.  */
13973   if (parms_have_cleanups)
13974     {
13975       pushlevel (0);
13976       if (!building_stmt_tree ())
13977         expand_start_bindings (2);
13978     }
13979
13980   /* Do the starting of the exception specifications, if we have any.  */
13981   if (flag_exceptions && !processing_template_decl
13982       && flag_enforce_eh_specs
13983       && building_stmt_tree ()
13984       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13985     current_eh_spec_try_block = expand_start_eh_spec ();
13986 }
13987
13988 /* Bind a name and initialization to the return value of
13989    the current function.  */
13990
13991 void
13992 store_return_init (decl)
13993      tree decl;
13994 {
13995   /* If this named return value comes in a register, put it in a
13996      pseudo-register.  */
13997   if (DECL_REGISTER (decl))
13998     {
13999       original_result_rtx = DECL_RTL (decl);
14000       /* Note that the mode of the old DECL_RTL may be wider than the
14001          mode of DECL_RESULT, depending on the calling conventions for
14002          the processor.  For example, on the Alpha, a 32-bit integer
14003          is returned in a DImode register -- the DECL_RESULT has
14004          SImode but the DECL_RTL for the DECL_RESULT has DImode.  So,
14005          here, we use the mode the back-end has already assigned for
14006          the return value.  */
14007       DECL_RTL (decl) = gen_reg_rtx (GET_MODE (original_result_rtx));
14008       if (TREE_ADDRESSABLE (decl))
14009         put_var_into_stack (decl);
14010     }
14011 }
14012
14013 \f
14014 /* We have finished doing semantic analysis on DECL, but have not yet
14015    generated RTL for its body.  Save away our current state, so that
14016    when we want to generate RTL later we know what to do.  */
14017
14018 static void
14019 save_function_data (decl)
14020      tree decl;
14021 {
14022   struct language_function *f;
14023
14024   /* Save the language-specific per-function data so that we can
14025      get it back when we really expand this function.  */
14026   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
14027                       19990908);
14028
14029   /* Make a copy.  */
14030   f = ((struct language_function *)
14031        xmalloc (sizeof (struct language_function)));
14032   bcopy ((char *) cp_function_chain, (char *) f,
14033          sizeof (struct language_function));
14034   DECL_SAVED_FUNCTION_DATA (decl) = f;
14035
14036   /* Clear out the bits we don't need.  */
14037   f->x_stmt_tree.x_last_stmt = NULL_TREE;
14038   f->x_stmt_tree.x_last_expr_type = NULL_TREE;
14039   f->x_result_rtx = NULL_RTX;
14040   f->x_named_label_uses = NULL;
14041   f->bindings = NULL;
14042
14043   /* When we get back here again, we will be expanding.  */
14044   f->x_expanding_p = 1;
14045
14046   /* If we've already decided that we cannot inline this function, we
14047      must remember that fact when we actually go to expand the
14048      function.  */
14049   f->cannot_inline = current_function_cannot_inline;
14050 }
14051
14052 /* At the end of every constructor we generate to code to return
14053    `this'.  Do that now.  */
14054
14055 static void
14056 finish_constructor_body ()
14057 {
14058   /* Any return from a constructor will end up here.  */
14059   if (ctor_label)
14060     add_tree (build_stmt (LABEL_STMT, ctor_label));
14061
14062   /* Clear CTOR_LABEL so that finish_return_stmt knows to really
14063      generate the return, rather than a goto to CTOR_LABEL.  */
14064   ctor_label = NULL_TREE;
14065   /* In check_return_expr we translate an empty return from a
14066      constructor to a return of `this'.  */
14067   finish_return_stmt (NULL_TREE);
14068   /* Mark the end of the constructor.  */
14069   add_tree (build_stmt (CTOR_STMT));
14070 }
14071
14072 /* At the end of every destructor we generate code to restore virtual
14073    function tables to the values desired by base classes and to call
14074    to base class destructors.  Do that now.  */
14075
14076 static void
14077 finish_destructor_body ()
14078 {
14079   tree compound_stmt;
14080   tree virtual_size;
14081   tree exprstmt;
14082   tree if_stmt;
14083
14084   /* Create a block to contain all the extra code.  */
14085   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
14086
14087   /* Any return from a destructor will end up here.  */
14088   add_tree (build_stmt (LABEL_STMT, dtor_label));
14089
14090   /* Generate the code to call destructor on base class.  If this
14091      destructor belongs to a class with virtual functions, then set
14092      the virtual function table pointer to represent the type of our
14093      base class.  */
14094
14095   /* This side-effect makes call to `build_delete' generate the code
14096      we have to have at the end of this destructor.  `build_delete'
14097      will set the flag again.  */
14098   TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
14099
14100   exprstmt = build_delete (current_class_type,
14101                            current_class_ref,
14102                            sfk_base_destructor,
14103                            LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
14104                            0);
14105
14106   if (exprstmt != error_mark_node
14107       && (TREE_CODE (exprstmt) != NOP_EXPR
14108           || TREE_OPERAND (exprstmt, 0) != integer_zero_node
14109           || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
14110     {
14111       if (exprstmt != void_zero_node)
14112         /* Don't call `expand_expr_stmt' if we're not going to do
14113            anything, since -Wall will give a diagnostic.  */
14114         finish_expr_stmt (exprstmt);
14115
14116       /* Run destructors for all virtual baseclasses.  */
14117       if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
14118         {
14119           tree vbases;
14120           tree if_stmt;
14121
14122           if_stmt = begin_if_stmt ();
14123           finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
14124                                       current_in_charge_parm,
14125                                       integer_two_node),
14126                                if_stmt);
14127
14128           vbases = CLASSTYPE_VBASECLASSES (current_class_type);
14129           /* The CLASSTYPE_VBASECLASSES list is in initialization
14130              order, so we have to march through it in reverse order.  */
14131           for (vbases = nreverse (copy_list (vbases));
14132                vbases;
14133                vbases = TREE_CHAIN (vbases))
14134             {
14135               tree vbase = TREE_VALUE (vbases);
14136
14137               if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (vbase)))
14138                 {
14139                   tree vb = get_vbase
14140                     (BINFO_TYPE (vbase),
14141                      TYPE_BINFO (current_class_type));
14142                   finish_expr_stmt
14143                     (build_scoped_method_call
14144                      (current_class_ref, vb, base_dtor_identifier,
14145                       NULL_TREE));
14146                 }
14147             }
14148
14149           finish_then_clause (if_stmt);
14150           finish_if_stmt ();
14151         }
14152     }
14153
14154   virtual_size = c_sizeof (current_class_type);
14155
14156   /* At the end, call delete if that's what's requested.  */
14157
14158   /* FDIS sez: At the point of definition of a virtual destructor
14159      (including an implicit definition), non-placement operator delete
14160      shall be looked up in the scope of the destructor's class and if
14161      found shall be accessible and unambiguous.
14162
14163      This is somewhat unclear, but I take it to mean that if the class
14164      only defines placement deletes we don't do anything here.  So we
14165      pass LOOKUP_SPECULATIVELY; delete_sanity will complain for us if
14166      they ever try to delete one of these.  */
14167   exprstmt = build_op_delete_call
14168     (DELETE_EXPR, current_class_ptr, virtual_size,
14169      LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
14170
14171   if_stmt = begin_if_stmt ();
14172   finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
14173                               current_in_charge_parm,
14174                               integer_one_node),
14175                        if_stmt);
14176   finish_expr_stmt (exprstmt);
14177   finish_then_clause (if_stmt);
14178   finish_if_stmt ();
14179
14180   /* Close the block we started above.  */
14181   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
14182 }
14183
14184 /* Finish up a function declaration and compile that function
14185    all the way to assembler language output.  The free the storage
14186    for the function definition.
14187
14188    FLAGS is a bitwise or of the following values:
14189      1 - CALL_POPLEVEL
14190        An extra call to poplevel (and expand_end_bindings) must be
14191        made to take care of the binding contour for the base
14192        initializers.  This is only relevant for constructors.
14193      2 - INCLASS_INLINE
14194        We just finished processing the body of an in-class inline
14195        function definition.  (This processing will have taken place
14196        after the class definition is complete.)  */
14197
14198 tree
14199 finish_function (flags)
14200      int flags;
14201 {
14202   register tree fndecl = current_function_decl;
14203   tree fntype, ctype = NULL_TREE;
14204   /* Label to use if this function is supposed to return a value.  */
14205   tree no_return_label = NULL_TREE;
14206   int call_poplevel = (flags & 1) != 0;
14207   int inclass_inline = (flags & 2) != 0;
14208   int expand_p;
14209   int nested;
14210   int current_line = lineno;
14211
14212   /* When we get some parse errors, we can end up without a
14213      current_function_decl, so cope.  */
14214   if (fndecl == NULL_TREE)
14215     return error_mark_node;
14216
14217   nested = function_depth > 1;
14218   fntype = TREE_TYPE (fndecl);
14219
14220   /*  TREE_READONLY (fndecl) = 1;
14221       This caused &foo to be of type ptr-to-const-function
14222       which then got a warning when stored in a ptr-to-function variable.  */
14223
14224   /* This happens on strange parse errors.  */
14225   if (! current_function_parms_stored)
14226     {
14227       call_poplevel = 0;
14228       store_parm_decls ();
14229     }
14230
14231   /* For a cloned function, we've already got all the code we need;
14232      there's no need to add any extra bits.  */
14233   if (building_stmt_tree () && DECL_CLONED_FUNCTION_P (fndecl))
14234     ;
14235   else if (building_stmt_tree ())
14236     {
14237       if (DECL_CONSTRUCTOR_P (fndecl))
14238         {
14239           finish_constructor_body ();
14240           if (call_poplevel)
14241             do_poplevel ();
14242         }
14243       else if (DECL_DESTRUCTOR_P (fndecl) && !processing_template_decl)
14244         finish_destructor_body ();
14245       else if (DECL_MAIN_P (fndecl))
14246         {
14247           /* Make it so that `main' always returns 0 by default.  */
14248 #ifdef VMS
14249           finish_return_stmt (integer_one_node);
14250 #else
14251           finish_return_stmt (integer_zero_node);
14252 #endif
14253         }
14254
14255       /* Finish dealing with exception specifiers.  */
14256       if (flag_exceptions && !processing_template_decl
14257           && flag_enforce_eh_specs
14258           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14259         expand_end_eh_spec (TYPE_RAISES_EXCEPTIONS
14260                             (TREE_TYPE (current_function_decl)),
14261                             current_eh_spec_try_block);
14262     }
14263   else
14264     {
14265 #if 0
14266       if (write_symbols != NO_DEBUG /*&& TREE_CODE (fntype) != METHOD_TYPE*/)
14267         {
14268           /* Keep this code around in case we later want to control debug info
14269              based on whether a type is "used".  (jason 1999-11-11) */
14270
14271           tree ttype = target_type (fntype);
14272           tree parmdecl;
14273
14274           if (IS_AGGR_TYPE (ttype))
14275             /* Let debugger know it should output info for this type.  */
14276             note_debug_info_needed (ttype);
14277
14278           for (parmdecl = DECL_ARGUMENTS (fndecl); parmdecl; parmdecl = TREE_CHAIN (parmdecl))
14279             {
14280               ttype = target_type (TREE_TYPE (parmdecl));
14281               if (IS_AGGR_TYPE (ttype))
14282                 /* Let debugger know it should output info for this type.  */
14283                 note_debug_info_needed (ttype);
14284             }
14285         }
14286 #endif
14287
14288       /* Clean house because we will need to reorder insns here.  */
14289       do_pending_stack_adjust ();
14290
14291       if (dtor_label)
14292         ;
14293       else if (DECL_CONSTRUCTOR_P (fndecl))
14294         {
14295           if (call_poplevel)
14296             do_poplevel ();
14297         }
14298       else if (return_label != NULL_RTX
14299                && flag_this_is_variable <= 0
14300                && current_function_return_value == NULL_TREE
14301                && ! DECL_NAME (DECL_RESULT (current_function_decl)))
14302         no_return_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
14303
14304       if (flag_exceptions)
14305         expand_exception_blocks ();
14306
14307       /* If this function is supposed to return a value, ensure that
14308          we do not fall into the cleanups by mistake.  The end of our
14309          function will look like this:
14310
14311          user code (may have return stmt somewhere)
14312          goto no_return_label
14313          cleanup_label:
14314          cleanups
14315          goto return_label
14316          no_return_label:
14317          NOTE_INSN_FUNCTION_END
14318          return_label:
14319          things for return
14320
14321          If the user omits a return stmt in the USER CODE section, we
14322          will have a control path which reaches NOTE_INSN_FUNCTION_END.
14323          Otherwise, we won't.  */
14324       if (no_return_label)
14325         {
14326           DECL_CONTEXT (no_return_label) = fndecl;
14327           DECL_INITIAL (no_return_label) = error_mark_node;
14328           DECL_SOURCE_FILE (no_return_label) = input_filename;
14329           DECL_SOURCE_LINE (no_return_label) = current_line;
14330           expand_goto (no_return_label);
14331         }
14332
14333       if (cleanup_label)
14334         {
14335           /* Remove the binding contour which is used
14336              to catch cleanup-generated temporaries.  */
14337           expand_end_bindings (0, 0, 0);
14338           poplevel (0, 0, 0);
14339
14340           /* Emit label at beginning of cleanup code for parameters.  */
14341           emit_label (cleanup_label);
14342         }
14343
14344       /* Get return value into register if that's where it's supposed
14345          to be.  */
14346       if (original_result_rtx)
14347         fixup_result_decl (DECL_RESULT (fndecl), original_result_rtx);
14348
14349       /* Finish building code that will trigger warnings if users forget
14350          to make their functions return values.  */
14351       if (no_return_label || cleanup_label)
14352         emit_jump (return_label);
14353       if (no_return_label)
14354         {
14355           /* We don't need to call `expand_*_return' here because we
14356              don't need any cleanups here--this path of code is only
14357              for error checking purposes.  */
14358           expand_label (no_return_label);
14359         }
14360
14361       /* We hard-wired immediate_size_expand to zero in
14362          start_function.  Expand_function_end will decrement this
14363          variable.  So, we set the variable to one here, so that after
14364          the decrement it will remain zero.  */
14365       immediate_size_expand = 1;
14366
14367       /* Generate rtl for function exit.  */
14368       expand_function_end (input_filename, current_line, 1);
14369     }
14370
14371   /* We have to save this value here in case
14372      maybe_end_member_template_processing decides to pop all the
14373      template parameters.  */
14374   expand_p = !building_stmt_tree ();
14375
14376   /* If we're saving up tree structure, tie off the function now.  */
14377   if (!expand_p)
14378     finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
14379
14380   /* This must come after expand_function_end because cleanups might
14381      have declarations (from inline functions) that need to go into
14382      this function's blocks.  */
14383   if (doing_semantic_analysis_p ())
14384     {
14385       if (current_binding_level->parm_flag != 1)
14386         my_friendly_abort (122);
14387       poplevel (1, 0, 1);
14388     }
14389
14390   /* Remember that we were in class scope.  */
14391   if (current_class_name)
14392     ctype = current_class_type;
14393
14394   /* Must mark the RESULT_DECL as being in this function.  */
14395   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
14396
14397   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14398      to the FUNCTION_DECL node itself.  */
14399   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
14400
14401   /* Save away current state, if appropriate.  */
14402   if (!expanding_p && !processing_template_decl)
14403     save_function_data (fndecl);
14404
14405   /* If this function calls `setjmp' it cannot be inlined.  When
14406      `longjmp' is called it is not guaranteed to restore the value of
14407      local variables that have been modified since the call to
14408      `setjmp'.  So, if were to inline this function into some caller
14409      `c', then when we `longjmp', we might not restore all variables
14410      in `c'.  (It might seem, at first blush, that there's no way for
14411      this function to modify local variables in `c', but their
14412      addresses may have been stored somewhere accessible to this
14413      function.)  */
14414   if (!expanding_p && !processing_template_decl && calls_setjmp_p (fndecl))
14415     DECL_UNINLINABLE (fndecl) = 1;
14416
14417   if (expand_p)
14418     {
14419       int returns_null;
14420       int returns_value;
14421
14422       /* So we can tell if jump_optimize sets it to 1.  */
14423       can_reach_end = 0;
14424
14425       /* Before we call rest_of_compilation (which will pop the
14426          CURRENT_FUNCTION), we must save these values.  */
14427       returns_null = current_function_returns_null;
14428       returns_value = current_function_returns_value;
14429
14430       /* If this is a nested function (like a template instantiation
14431          that we're compiling in the midst of compiling something
14432          else), push a new GC context.  That will keep local variables
14433          on the stack from being collected while we're doing the
14434          compilation of this function.  */
14435       if (function_depth > 1)
14436         ggc_push_context ();
14437
14438       /* Run the optimizers and output the assembler code for this
14439          function.  */
14440       rest_of_compilation (fndecl);
14441
14442       /* Undo the call to ggc_push_context above.  */
14443       if (function_depth > 1)
14444         ggc_pop_context ();
14445
14446       if (DECL_SAVED_INSNS (fndecl) && ! TREE_ASM_WRITTEN (fndecl))
14447         {
14448           /* Set DECL_EXTERNAL so that assemble_external will be called as
14449              necessary.  We'll clear it again in finish_file.  */
14450           if (! DECL_EXTERNAL (fndecl))
14451             DECL_NOT_REALLY_EXTERN (fndecl) = 1;
14452           DECL_EXTERNAL (fndecl) = 1;
14453           defer_fn (fndecl);
14454         }
14455
14456 #if 0
14457       /* Keep this code around in case we later want to control debug info
14458          based on whether a type is "used".  (jason 1999-11-11) */
14459
14460       if (ctype && TREE_ASM_WRITTEN (fndecl))
14461         note_debug_info_needed (ctype);
14462 #endif
14463
14464       if (DECL_NAME (DECL_RESULT (fndecl)))
14465         returns_value |= can_reach_end;
14466       else
14467         returns_null |= can_reach_end;
14468
14469       if (TREE_THIS_VOLATILE (fndecl) && returns_null)
14470         warning ("`noreturn' function does return");
14471       else if (returns_null
14472                && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE)
14473         {
14474           /* Always complain if there's just no return statement.  */
14475           if (!returns_value)
14476             warning ("no return statement in function returning non-void");
14477           else if (warn_return_type || pedantic)
14478             /* If this function returns non-void and control can drop through,
14479                complain.  */
14480             warning ("control reaches end of non-void function");
14481         }
14482     }
14483   else
14484     {
14485       /* Clear out memory we no longer need.  */
14486       free_after_parsing (cfun);
14487       /* Since we never call rest_of_compilation, we never clear
14488          CFUN.  Do so explicitly.  */
14489       free_after_compilation (cfun);
14490       cfun = NULL;
14491     }
14492
14493   /* If this is a in-class inline definition, we may have to pop the
14494      bindings for the template parameters that we added in
14495      maybe_begin_member_template_processing when start_function was
14496      called.  */
14497   if (inclass_inline)
14498     maybe_end_member_template_processing ();
14499
14500   /* Leave the scope of the class.  */
14501   if (ctype)
14502     pop_nested_class ();
14503
14504   --function_depth;
14505
14506   if (!DECL_SAVED_INSNS (fndecl) && !DECL_SAVED_FUNCTION_DATA (fndecl)
14507       && !(flag_inline_trees && DECL_INLINE (fndecl)))
14508     {
14509       tree t;
14510
14511       /* Stop pointing to the local nodes about to be freed.  */
14512       /* But DECL_INITIAL must remain nonzero so we know this
14513          was an actual function definition.  */
14514       DECL_INITIAL (fndecl) = error_mark_node;
14515       for (t = DECL_ARGUMENTS (fndecl); t; t = TREE_CHAIN (t))
14516         DECL_RTL (t) = DECL_INCOMING_RTL (t) = NULL_RTX;
14517     }
14518
14519   if (DECL_STATIC_CONSTRUCTOR (fndecl))
14520     static_ctors = tree_cons (NULL_TREE, fndecl, static_ctors);
14521   if (DECL_STATIC_DESTRUCTOR (fndecl))
14522     static_dtors = tree_cons (NULL_TREE, fndecl, static_dtors);
14523
14524   /* Clean up.  */
14525   if (! nested)
14526     {
14527       /* Let the error reporting routines know that we're outside a
14528          function.  For a nested function, this value is used in
14529          pop_cp_function_context and then reset via pop_function_context.  */
14530       current_function_decl = NULL_TREE;
14531       /* We don't really care about obstacks, but the middle-end
14532          sometimes cares on what obstck things are located.  */
14533       permanent_allocation (1);
14534     }
14535
14536   return fndecl;
14537 }
14538 \f
14539 /* Create the FUNCTION_DECL for a function definition.
14540    DECLSPECS and DECLARATOR are the parts of the declaration;
14541    they describe the return type and the name of the function,
14542    but twisted together in a fashion that parallels the syntax of C.
14543
14544    This function creates a binding context for the function body
14545    as well as setting up the FUNCTION_DECL in current_function_decl.
14546
14547    Returns a FUNCTION_DECL on success.
14548
14549    If the DECLARATOR is not suitable for a function (it defines a datum
14550    instead), we return 0, which tells yyparse to report a parse error.
14551
14552    May return void_type_node indicating that this method is actually
14553    a friend.  See grokfield for more details.
14554
14555    Came here with a `.pushlevel' .
14556
14557    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14558    CHANGES TO CODE IN `grokfield'.  */
14559
14560 tree
14561 start_method (declspecs, declarator, attrlist)
14562      tree declarator, declspecs, attrlist;
14563 {
14564   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14565                                 attrlist);
14566
14567   /* Something too ugly to handle.  */
14568   if (fndecl == NULL_TREE)
14569     return NULL_TREE;
14570
14571   /* Pass friends other than inline friend functions back.  */
14572   if (fndecl == void_type_node)
14573     return fndecl;
14574
14575   if (TREE_CODE (fndecl) != FUNCTION_DECL)
14576     /* Not a function, tell parser to report parse error.  */
14577     return NULL_TREE;
14578
14579   if (DECL_IN_AGGR_P (fndecl))
14580     {
14581       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14582         {
14583           if (DECL_CONTEXT (fndecl)
14584               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14585             cp_error ("`%D' is already defined in class %s", fndecl,
14586                              TYPE_NAME_STRING (DECL_CONTEXT (fndecl)));
14587         }
14588       return void_type_node;
14589     }
14590
14591   check_template_shadow (fndecl);
14592
14593   DECL_THIS_INLINE (fndecl) = 1;
14594
14595   if (flag_default_inline)
14596     DECL_INLINE (fndecl) = 1;
14597
14598   /* We process method specializations in finish_struct_1.  */
14599   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14600     fndecl = push_template_decl (fndecl);
14601
14602   if (! DECL_FRIEND_P (fndecl))
14603     {
14604       if (TREE_CHAIN (fndecl))
14605         {
14606           fndecl = copy_node (fndecl);
14607           TREE_CHAIN (fndecl) = NULL_TREE;
14608         }
14609
14610       if (DECL_CONSTRUCTOR_P (fndecl))
14611         {
14612           if (! grok_ctor_properties (current_class_type, fndecl))
14613             return void_type_node;
14614         }
14615       else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl)))
14616         grok_op_properties (fndecl, DECL_VIRTUAL_P (fndecl), 0);
14617     }
14618
14619   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14620
14621   /* Make a place for the parms */
14622   pushlevel (0);
14623   current_binding_level->parm_flag = 1;
14624
14625   DECL_IN_AGGR_P (fndecl) = 1;
14626   return fndecl;
14627 }
14628
14629 /* Go through the motions of finishing a function definition.
14630    We don't compile this method until after the whole class has
14631    been processed.
14632
14633    FINISH_METHOD must return something that looks as though it
14634    came from GROKFIELD (since we are defining a method, after all).
14635
14636    This is called after parsing the body of the function definition.
14637    STMTS is the chain of statements that makes up the function body.
14638
14639    DECL is the ..._DECL that `start_method' provided.  */
14640
14641 tree
14642 finish_method (decl)
14643      tree decl;
14644 {
14645   register tree fndecl = decl;
14646   tree old_initial;
14647
14648   register tree link;
14649
14650   if (decl == void_type_node)
14651     return decl;
14652
14653   old_initial = DECL_INITIAL (fndecl);
14654
14655   /* Undo the level for the parms (from start_method).
14656      This is like poplevel, but it causes nothing to be
14657      saved.  Saving information here confuses symbol-table
14658      output routines.  Besides, this information will
14659      be correctly output when this method is actually
14660      compiled.  */
14661
14662   /* Clear out the meanings of the local variables of this level;
14663      also record in each decl which block it belongs to.  */
14664
14665   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14666     {
14667       if (DECL_NAME (link) != NULL_TREE)
14668         pop_binding (DECL_NAME (link), link);
14669       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14670       DECL_CONTEXT (link) = NULL_TREE;
14671     }
14672
14673   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
14674                       (HOST_WIDE_INT) current_binding_level->level_chain,
14675                       current_binding_level->parm_flag,
14676                       current_binding_level->keep);
14677
14678   poplevel (0, 0, 0);
14679
14680   DECL_INITIAL (fndecl) = old_initial;
14681
14682   /* We used to check if the context of FNDECL was different from
14683      current_class_type as another way to get inside here.  This didn't work
14684      for String.cc in libg++.  */
14685   if (DECL_FRIEND_P (fndecl))
14686     {
14687       CLASSTYPE_INLINE_FRIENDS (current_class_type)
14688         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14689       decl = void_type_node;
14690     }
14691
14692   return decl;
14693 }
14694 \f
14695 /* Called when a new struct TYPE is defined.
14696    If this structure or union completes the type of any previous
14697    variable declaration, lay it out and output its rtl.  */
14698
14699 void
14700 hack_incomplete_structures (type)
14701      tree type;
14702 {
14703   tree *list;
14704   struct binding_level *level;
14705
14706   if (!type) /* Don't do this for class templates.  */
14707     return;
14708
14709   if (namespace_bindings_p ())
14710     {
14711       level = 0;
14712       list = &namespace_scope_incomplete;
14713     }
14714   else
14715     {
14716       level = innermost_nonclass_level ();
14717       list = &level->incomplete;
14718     }
14719
14720   while (1)
14721     {
14722       while (*list)
14723         {
14724           tree decl = TREE_VALUE (*list);
14725           if ((decl && TREE_TYPE (decl) == type)
14726               || (TREE_TYPE (decl)
14727                   && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14728                   && TREE_TYPE (TREE_TYPE (decl)) == type))
14729             {
14730               int toplevel = toplevel_bindings_p ();
14731               if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14732                   && TREE_TYPE (TREE_TYPE (decl)) == type)
14733                 layout_type (TREE_TYPE (decl));
14734               layout_decl (decl, 0);
14735               rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
14736               if (! toplevel)
14737                 {
14738                   tree cleanup;
14739                   expand_decl (decl);
14740                   cleanup = maybe_build_cleanup (decl);
14741                   expand_decl_init (decl);
14742                   if (! expand_decl_cleanup (decl, cleanup))
14743                     cp_error ("parser lost in parsing declaration of `%D'",
14744                               decl);
14745                 }
14746               *list = TREE_CHAIN (*list);
14747             }
14748           else
14749             list = &TREE_CHAIN (*list);
14750         }
14751
14752       /* Keep looking through artificial binding levels generated
14753          for local variables.  */
14754       if (level && level->keep == 2)
14755         {
14756           level = level->level_chain;
14757           list = &level->incomplete;
14758         }
14759       else
14760         break;
14761     }
14762 }
14763
14764 /* If DECL is of a type which needs a cleanup, build that cleanup
14765    here.  */
14766
14767 tree
14768 maybe_build_cleanup (decl)
14769      tree decl;
14770 {
14771   tree type = TREE_TYPE (decl);
14772
14773   if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14774     {
14775       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14776       tree rval;
14777
14778       if (TREE_CODE (type) == ARRAY_TYPE)
14779         rval = decl;
14780       else
14781         {
14782           mark_addressable (decl);
14783           rval = build_unary_op (ADDR_EXPR, decl, 0);
14784         }
14785
14786       /* Optimize for space over speed here.  */
14787       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14788           || flag_expensive_optimizations)
14789         flags |= LOOKUP_NONVIRTUAL;
14790
14791       rval = build_delete (TREE_TYPE (rval), rval,
14792                            sfk_complete_destructor, flags, 0);
14793
14794       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14795           && ! TYPE_HAS_DESTRUCTOR (type))
14796         rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14797                                                build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14798
14799       return rval;
14800     }
14801   return 0;
14802 }
14803 \f
14804 /* Expand a C++ expression at the statement level.
14805    This is needed to ferret out nodes which have UNKNOWN_TYPE.
14806    The C++ type checker should get all of these out when
14807    expressions are combined with other, type-providing, expressions,
14808    leaving only orphan expressions, such as:
14809
14810    &class::bar;         / / takes its address, but does nothing with it.  */
14811
14812 void
14813 cplus_expand_expr_stmt (exp)
14814      tree exp;
14815 {
14816 #if 0
14817   /* We should do this eventually, but right now this causes regex.o from
14818      libg++ to miscompile, and tString to core dump.  */
14819   exp = build1 (CLEANUP_POINT_EXPR, TREE_TYPE (exp), exp);
14820 #endif
14821
14822   /* If we don't do this, we end up down inside expand_expr
14823      trying to do TYPE_MODE on the ERROR_MARK, and really
14824      go outside the bounds of the type.  */
14825   if (exp != error_mark_node)
14826     expand_expr_stmt (exp);
14827 }
14828
14829 /* When a stmt has been parsed, this function is called.  */
14830
14831 void
14832 finish_stmt ()
14833 {
14834   /* Always assume this statement was not an expression statement.  If
14835      it actually was an expression statement, its our callers
14836      responsibility to fix this up.  */
14837   last_expr_type = NULL_TREE;
14838 }
14839
14840 /* DECL was originally constructed as a non-static member function,
14841    but turned out to be static.  Update it accordingly.  */
14842
14843 void
14844 revert_static_member_fn (decl)
14845      tree decl;
14846 {
14847   tree tmp;
14848   tree function = TREE_TYPE (decl);
14849   tree args = TYPE_ARG_TYPES (function);
14850
14851   if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args)))
14852       != TYPE_UNQUALIFIED)
14853     cp_error ("static member function `%#D' declared with type qualifiers",
14854               *decl);
14855
14856   args = TREE_CHAIN (args);
14857   tmp = build_function_type (TREE_TYPE (function), args);
14858   tmp = build_qualified_type (tmp, CP_TYPE_QUALS (function));
14859   tmp = build_exception_variant (tmp,
14860                                  TYPE_RAISES_EXCEPTIONS (function));
14861   TREE_TYPE (decl) = tmp;
14862   if (DECL_ARGUMENTS (decl))
14863     DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
14864   DECL_STATIC_FUNCTION_P (decl) = 1;
14865 }
14866
14867 /* Initialize the variables used during compilation of a C++
14868    function.  */
14869
14870 static void
14871 push_cp_function_context (f)
14872      struct function *f;
14873 {
14874   struct language_function *p
14875     = ((struct language_function *)
14876        xcalloc (1, sizeof (struct language_function)));
14877   f->language = p;
14878
14879   /* It takes an explicit call to expand_body to generate RTL for a
14880      function.  */
14881   expanding_p = 0;
14882
14883   /* Whenever we start a new function, we destroy temporaries in the
14884      usual way.  */
14885   current_stmt_tree->stmts_are_full_exprs_p = 1;
14886 }
14887
14888 /* Free the language-specific parts of F, now that we've finished
14889    compiling the function.  */
14890
14891 static void
14892 pop_cp_function_context (f)
14893      struct function *f;
14894 {
14895   if (f->language)
14896     free (f->language);
14897   f->language = 0;
14898 }
14899
14900 /* Mark P for GC.  */
14901
14902 static void
14903 mark_lang_function (p)
14904      struct language_function *p;
14905 {
14906   if (!p)
14907     return;
14908
14909   ggc_mark_tree (p->x_ctor_label);
14910   ggc_mark_tree (p->x_dtor_label);
14911   ggc_mark_tree (p->x_current_class_ptr);
14912   ggc_mark_tree (p->x_current_class_ref);
14913   ggc_mark_tree (p->x_eh_spec_try_block);
14914   ggc_mark_tree (p->x_scope_stmt_stack);
14915
14916   ggc_mark_rtx (p->x_result_rtx);
14917
14918   mark_named_label_lists (&p->x_named_labels, &p->x_named_label_uses);
14919   mark_stmt_tree (&p->x_stmt_tree);
14920   mark_binding_level (&p->bindings);
14921 }
14922
14923 /* Mark the language-specific data in F for GC.  */
14924
14925 static void
14926 mark_cp_function_context (f)
14927      struct function *f;
14928 {
14929   mark_lang_function (f->language);
14930 }
14931
14932 void
14933 lang_mark_false_label_stack (l)
14934      struct label_node *l;
14935 {
14936   /* C++ doesn't use false_label_stack.  It better be NULL.  */
14937   my_friendly_assert (l == NULL, 19990904);
14938 }
14939
14940 void
14941 lang_mark_tree (t)
14942      tree t;
14943 {
14944   enum tree_code code = TREE_CODE (t);
14945   if (code == IDENTIFIER_NODE)
14946     {
14947       struct lang_identifier *li = (struct lang_identifier *) t;
14948       struct lang_id2 *li2 = li->x;
14949       ggc_mark_tree (li->namespace_bindings);
14950       ggc_mark_tree (li->bindings);
14951       ggc_mark_tree (li->class_value);
14952       ggc_mark_tree (li->class_template_info);
14953
14954       if (li2)
14955         {
14956           ggc_mark_tree (li2->label_value);
14957           ggc_mark_tree (li2->implicit_decl);
14958           ggc_mark_tree (li2->error_locus);
14959         }
14960     }
14961   else if (code == CPLUS_BINDING)
14962     {
14963       if (BINDING_HAS_LEVEL_P (t))
14964         mark_binding_level (&BINDING_LEVEL (t));
14965       else
14966         ggc_mark_tree (BINDING_SCOPE (t));
14967       ggc_mark_tree (BINDING_VALUE (t));
14968     }
14969   else if (code == OVERLOAD)
14970     ggc_mark_tree (OVL_FUNCTION (t));
14971   else if (code == TEMPLATE_PARM_INDEX)
14972     ggc_mark_tree (TEMPLATE_PARM_DECL (t));
14973   else if (TREE_CODE_CLASS (code) == 'd')
14974     {
14975       struct lang_decl *ld = DECL_LANG_SPECIFIC (t);
14976
14977       if (ld)
14978         {
14979           ggc_mark (ld);
14980           if (!DECL_GLOBAL_CTOR_P (t)
14981               && !DECL_GLOBAL_DTOR_P (t)
14982               && !DECL_THUNK_P (t))
14983             ggc_mark_tree (ld->decl_flags.u2.access);
14984           else if (DECL_THUNK_P (t))
14985             ggc_mark_tree (ld->decl_flags.u2.vcall_offset);
14986           ggc_mark_tree (ld->decl_flags.context);
14987           if (TREE_CODE (t) != NAMESPACE_DECL)
14988             ggc_mark_tree (ld->decl_flags.u.template_info);
14989           else
14990             mark_binding_level (&NAMESPACE_LEVEL (t));
14991           if (CAN_HAVE_FULL_LANG_DECL_P (t))
14992             {
14993               ggc_mark_tree (ld->befriending_classes);
14994               ggc_mark_tree (ld->saved_tree);
14995               ggc_mark_tree (ld->cloned_function);
14996               if (!DECL_OVERLOADED_OPERATOR_P (t))
14997                 ggc_mark_tree (ld->u2.vtt_parm);
14998               if (TREE_CODE (t) == TYPE_DECL)
14999                 ggc_mark_tree (ld->u.sorted_fields);
15000               else if (TREE_CODE (t) == FUNCTION_DECL
15001                        && !DECL_PENDING_INLINE_P (t))
15002                 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t));
15003             }
15004         }
15005     }
15006   else if (TREE_CODE_CLASS (code) == 't')
15007     {
15008       struct lang_type *lt = TYPE_LANG_SPECIFIC (t);
15009
15010       if (lt && !(TREE_CODE (t) == POINTER_TYPE
15011                   && TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE))
15012         {
15013           ggc_mark (lt);
15014           ggc_mark_tree (lt->primary_base);
15015           ggc_mark_tree (lt->vfields);
15016           ggc_mark_tree (lt->vbases);
15017           ggc_mark_tree (lt->tags);
15018           ggc_mark_tree (lt->size);
15019           ggc_mark_tree (lt->pure_virtuals);
15020           ggc_mark_tree (lt->friend_classes);
15021           ggc_mark_tree (lt->rtti);
15022           ggc_mark_tree (lt->methods);
15023           ggc_mark_tree (lt->template_info);
15024           ggc_mark_tree (lt->befriending_classes);
15025         }
15026       else if (lt)
15027         /* In the case of pointer-to-member function types, the
15028            TYPE_LANG_SPECIFIC is really just a tree.  */
15029         ggc_mark_tree ((tree) lt);
15030     }
15031 }