gcc/cp/decl.c

   1 /* Process declarations and variables for C compiler.
   2    Copyright (C) 1988, 92-98, 1999 Free Software Foundation, Inc.
   3    Contributed by Michael Tiemann (tiemann@cygnus.com)
   4
   5 This file is part of GNU CC.
   6
   7 GNU CC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU CC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU CC; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.  */
  21
  22
  23 /* Process declarations and symbol lookup for C front end.
  24    Also constructs types; the standard scalar types at initialization,
  25    and structure, union, array and enum types when they are declared.  */
  26
  27 /* ??? not all decl nodes are given the most useful possible
  28    line numbers.  For example, the CONST_DECLs for enum values.  */
  29
  30 #include "config.h"
  31 #include "system.h"
  32 #include "tree.h"
  33 #include "rtl.h"
  34 #include "flags.h"
  35 #include "cp-tree.h"
  36 #include "decl.h"
  37 #include "lex.h"
  38 #include <signal.h>
  39 #include "obstack.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 #define obstack_chunk_alloc xmalloc
  49 #define obstack_chunk_free free
  50
  51 extern struct obstack permanent_obstack;
  52 extern struct obstack* saveable_obstack;
  53
  54 extern int current_class_depth;
  55
  56 extern tree static_ctors, static_dtors;
  57
  58 extern tree global_namespace;
  59
  60 extern int (*valid_lang_attribute) PROTO ((tree, tree, tree, tree));
  61
  62 /* Use garbage collection.  */
  63
  64 int ggc_p = 1;
  65
  66 #ifndef WCHAR_UNSIGNED
  67 #define WCHAR_UNSIGNED 0
  68 #endif
  69
  70 #ifndef CHAR_TYPE_SIZE
  71 #define CHAR_TYPE_SIZE BITS_PER_UNIT
  72 #endif
  73
  74 #ifndef BOOL_TYPE_SIZE
  75 #ifdef SLOW_BYTE_ACCESS
  76 #define BOOL_TYPE_SIZE ((SLOW_BYTE_ACCESS) ? (POINTER_SIZE) : (CHAR_TYPE_SIZE))
  77 #else
  78 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
  79 #endif
  80 #endif
  81
  82 /* We let tm.h override the types used here, to handle trivial differences
  83    such as the choice of unsigned int or long unsigned int for size_t.
  84    When machines start needing nontrivial differences in the size type,
  85    it would be best to do something here to figure out automatically
  86    from other information what type to use.  */
  87
  88 #ifndef SIZE_TYPE
  89 #define SIZE_TYPE "long unsigned int"
  90 #endif
  91
  92 #ifndef PTRDIFF_TYPE
  93 #define PTRDIFF_TYPE "long int"
  94 #endif
  95
  96 #ifndef WCHAR_TYPE
  97 #define WCHAR_TYPE "int"
  98 #endif
  99
 100 static tree grokparms                           PROTO((tree, int));
 101 static const char *redeclaration_error_message  PROTO((tree, tree));
 102
 103 static void push_binding_level PROTO((struct binding_level *, int,
 104                                       int));
 105 static void pop_binding_level PROTO((void));
 106 static void suspend_binding_level PROTO((void));
 107 static void resume_binding_level PROTO((struct binding_level *));
 108 static struct binding_level *make_binding_level PROTO((void));
 109 static void declare_namespace_level PROTO((void));
 110 static void signal_catch PROTO((int)) ATTRIBUTE_NORETURN;
 111 static void storedecls PROTO((tree));
 112 static void require_complete_types_for_parms PROTO((tree));
 113 static void push_overloaded_decl_1 PROTO((tree));
 114 static int ambi_op_p PROTO((tree));
 115 static int unary_op_p PROTO((tree));
 116 static tree store_bindings PROTO((tree, tree));
 117 static tree lookup_tag_reverse PROTO((tree, tree));
 118 static tree obscure_complex_init PROTO((tree, tree));
 119 static tree maybe_build_cleanup_1 PROTO((tree, tree));
 120 static tree lookup_name_real PROTO((tree, int, int, int));
 121 static void warn_extern_redeclared_static PROTO((tree, tree));
 122 static void grok_reference_init PROTO((tree, tree, tree));
 123 static tree grokfndecl PROTO((tree, tree, tree, tree, int,
 124                               enum overload_flags, tree,
 125                               tree, int, int, int, int, int, int, tree));
 126 static tree grokvardecl PROTO((tree, tree, RID_BIT_TYPE *, int, int, tree));
 127 static tree lookup_tag PROTO((enum tree_code, tree,
 128                               struct binding_level *, int));
 129 static void set_identifier_type_value_with_scope
 130         PROTO((tree, tree, struct binding_level *));
 131 static void record_builtin_type PROTO((enum rid, const char *, tree));
 132 static void record_unknown_type PROTO((tree, const char *));
 133 static int member_function_or_else PROTO((tree, tree, const char *));
 134 static void bad_specifiers PROTO((tree, const char *, int, int, int, int,
 135                                   int));
 136 static void lang_print_error_function PROTO((const char *));
 137 static tree maybe_process_template_type_declaration PROTO((tree, int, struct binding_level*));
 138 static void check_for_uninitialized_const_var PROTO((tree));
 139 static unsigned long typename_hash PROTO((hash_table_key));
 140 static boolean typename_compare PROTO((hash_table_key, hash_table_key));
 141 static void push_binding PROTO((tree, tree, struct binding_level*));
 142 static int add_binding PROTO((tree, tree));
 143 static void pop_binding PROTO((tree, tree));
 144 static tree local_variable_p PROTO((tree *, int *, void *));
 145 static tree find_binding PROTO((tree, tree));
 146 static tree select_decl PROTO((tree, int));
 147 static int lookup_flags PROTO((int, int));
 148 static tree qualify_lookup PROTO((tree, int));
 149 static tree record_builtin_java_type PROTO((const char *, int));
 150 static const char *tag_name PROTO((enum tag_types code));
 151 static void find_class_binding_level PROTO((void));
 152 static struct binding_level *innermost_nonclass_level PROTO((void));
 153 static void warn_about_implicit_typename_lookup PROTO((tree, tree));
 154 static int walk_namespaces_r PROTO((tree, walk_namespaces_fn, void *));
 155 static int walk_globals_r PROTO((tree, void *));
 156 static void add_decl_to_level PROTO((tree, struct binding_level *));
 157 static tree make_label_decl PROTO((tree, int));
 158 static void pop_label PROTO((tree));
 159 static void pop_labels PROTO((tree));
 160 static void maybe_deduce_size_from_array_init PROTO((tree, tree));
 161 static void layout_var_decl PROTO((tree));
 162 static void maybe_commonize_var PROTO((tree));
 163 static tree check_initializer PROTO((tree, tree));
 164 static void make_rtl_for_nonlocal_decl PROTO((tree, tree, const char *));
 165 static void push_cp_function_context PROTO((struct function *));
 166 static void pop_cp_function_context PROTO((struct function *));
 167 static void mark_binding_level PROTO((void *));
 168 static void mark_cp_function_context PROTO((struct function *));
 169 static void mark_saved_scope PROTO((void *));
 170 static void mark_lang_function PROTO((struct language_function *));
 171 static void mark_stmt_tree PROTO((struct stmt_tree *));
 172 static void save_function_data PROTO((tree));
 173 static void check_function_type PROTO((tree));
 174 static void destroy_local_static PROTO((tree));
 175 static void destroy_local_var PROTO((tree));
 176 static void finish_constructor_body PROTO((void));
 177 static void finish_destructor_body PROTO((void));
 178 static tree compute_array_index_type PROTO((tree, tree));
 179 static tree create_array_type_for_decl PROTO((tree, tree, tree));
 180
 181 #if defined (DEBUG_CP_BINDING_LEVELS)
 182 static void indent PROTO((void));
 183 #endif
 184
 185 /* Erroneous argument lists can use this *IFF* they do not modify it.  */
 186 tree error_mark_list;
 187
 188 /* The following symbols are subsumed in the cp_global_trees array, and
 189    listed here individually for documentation purposes.
 190
 191    C++ extensions
 192         tree wchar_decl_node;
 193         tree void_zero_node;
 194
 195         tree vtable_entry_type;
 196         tree delta_type_node;
 197 #if 0
 198    Old rtti stuff.
 199         tree __baselist_desc_type_node;
 200         tree __i_desc_type_node, __m_desc_type_node;
 201         tree __t_desc_array_type, __i_desc_array_type, __m_desc_array_type;
 202 #endif
 203         tree __t_desc_type_node;
 204 #if 0
 205         tree __tp_desc_type_node;
 206 #endif
 207         tree __access_mode_type_node;
 208         tree __bltn_desc_type_node, __user_desc_type_node, __class_desc_type_node;
 209         tree __ptr_desc_type_node, __attr_desc_type_node, __func_desc_type_node;
 210         tree __ptmf_desc_type_node, __ptmd_desc_type_node;
 211 #if 0
 212    Not needed yet?  May be needed one day?
 213         tree __bltn_desc_array_type, __user_desc_array_type, __class_desc_array_type;
 214         tree __ptr_desc_array_type, __attr_dec_array_type, __func_desc_array_type;
 215         tree __ptmf_desc_array_type, __ptmd_desc_array_type;
 216 #endif
 217
 218         tree class_star_type_node;
 219         tree class_type_node, record_type_node, union_type_node, enum_type_node;
 220         tree unknown_type_node;
 221
 222    Array type `vtable_entry_type[]'
 223
 224         tree vtbl_type_node;
 225         tree vtbl_ptr_type_node;
 226
 227    Nnamespace std
 228
 229         tree std_node;
 230
 231    A FUNCTION_DECL which can call `abort'.  Not necessarily the
 232    one that the user will declare, but sufficient to be called
 233    by routines that want to abort the program.
 234
 235         tree abort_fndecl;
 236
 237    The FUNCTION_DECL for the default `::operator delete'.
 238
 239         tree global_delete_fndecl;
 240
 241    Used by RTTI
 242         tree type_info_type_node, tinfo_fn_id, tinfo_fn_type;
 243
 244 */
 245
 246 tree cp_global_trees[CPTI_MAX];
 247
 248 /* Indicates that there is a type value in some namespace, although
 249    that is not necessarily in scope at the moment.  */
 250
 251 static tree global_type_node;
 252
 253 /* Namespace std.  */
 254 int in_std;
 255
 256 /* Expect only namespace names now. */
 257 static int only_namespace_names;
 258
 259 /* If original DECL_RESULT of current function was a register,
 260    but due to being an addressable named return value, would up
 261    on the stack, this variable holds the named return value's
 262    original location.  */
 263
 264 #define original_result_rtx cp_function_chain->x_result_rtx
 265
 266 struct named_label_list
 267 {
 268   struct binding_level *binding_level;
 269   tree names_in_scope;
 270   tree label_decl;
 271   const char *filename_o_goto;
 272   int lineno_o_goto;
 273   struct named_label_list *next;
 274 };
 275
 276 /* Used only for jumps to as-yet undefined labels, since jumps to
 277    defined labels can have their validity checked by stmt.c.  */
 278
 279 #define named_label_uses cp_function_chain->x_named_label_uses
 280
 281 /* A list of objects which have constructors or destructors
 282    which reside in the global scope.  The decl is stored in
 283    the TREE_VALUE slot and the initializer is stored
 284    in the TREE_PURPOSE slot.  */
 285 tree static_aggregates;
 286
 287 /* -- end of C++ */
 288
 289 /* A node for the integer constants 2, and 3.  */
 290
 291 tree integer_two_node, integer_three_node;
 292
 293 /* While defining an enum type, this is 1 plus the last enumerator
 294    constant value.  */
 295
 296 static tree enum_next_value;
 297
 298 /* Nonzero means that there was overflow computing enum_next_value.  */
 299
 300 static int enum_overflow;
 301
 302 /* Parsing a function declarator leaves here a chain of structure
 303    and enum types declared in the parmlist.  */
 304
 305 static tree last_function_parm_tags;
 306
 307 /* Similar, for last_function_parm_tags.  */
 308 tree last_function_parms;
 309 static tree current_function_parm_tags;
 310
 311 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
 312    that have names.  Here so we can clear out their names' definitions
 313    at the end of the function.  The TREE_VALUE is a LABEL_DECL; the
 314    TREE_PURPOSE is the previous binding of the label.  */
 315
 316 #define named_labels cp_function_chain->x_named_labels
 317
 318 /* The FUNCTION_DECL for the function currently being compiled,
 319    or 0 if between functions.  */
 320 tree current_function_decl;
 321
 322 /* Set to 0 at beginning of a function definition, and whenever
 323    a label (case or named) is defined.  Set to value of expression
 324    returned from function when that value can be transformed into
 325    a named return value.  */
 326
 327 tree current_function_return_value;
 328
 329 /* Nonzero means give `double' the same size as `float'.  */
 330
 331 extern int flag_short_double;
 332
 333 /* Nonzero means don't recognize any builtin functions.  */
 334
 335 extern int flag_no_builtin;
 336
 337 /* Nonzero means don't recognize the non-ANSI builtin functions.
 338    -ansi sets this.  */
 339
 340 extern int flag_no_nonansi_builtin;
 341
 342 /* Nonzero if we want to support huge (> 2^(sizeof(short)*8-1) bytes)
 343    objects.  */
 344 extern int flag_huge_objects;
 345
 346 /* Nonzero if we want to conserve space in the .o files.  We do this
 347    by putting uninitialized data and runtime initialized data into
 348    .common instead of .data at the expense of not flagging multiple
 349    definitions.  */
 350 extern int flag_conserve_space;
 351 \f
 352 /* C and C++ flags are in decl2.c.  */
 353
 354 /* Flag used when debugging spew.c */
 355
 356 extern int spew_debug;
 357
 358 /* A expression of value 0 with the same precision as a sizetype
 359    node, but signed.  */
 360 tree signed_size_zero_node;
 361
 362 /* The name of the anonymous namespace, throughout this translation
 363    unit.  */
 364 tree anonymous_namespace_name;
 365
 366 \f
 367 /* For each binding contour we allocate a binding_level structure
 368    which records the names defined in that contour.
 369    Contours include:
 370     0) the global one
 371     1) one for each function definition,
 372        where internal declarations of the parameters appear.
 373     2) one for each compound statement,
 374        to record its declarations.
 375
 376    The current meaning of a name can be found by searching the levels
 377    from the current one out to the global one.
 378
 379    Off to the side, may be the class_binding_level.  This exists only
 380    to catch class-local declarations.  It is otherwise nonexistent.
 381
 382    Also there may be binding levels that catch cleanups that must be
 383    run when exceptions occur.  Thus, to see whether a name is bound in
 384    the current scope, it is not enough to look in the
 385    CURRENT_BINDING_LEVEL.  You should use lookup_name_current_level
 386    instead.  */
 387
 388 /* Note that the information in the `names' component of the global contour
 389    is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers.  */
 390
 391 struct binding_level
 392   {
 393     /* A chain of _DECL nodes for all variables, constants, functions,
 394        and typedef types.  These are in the reverse of the order
 395        supplied.  There may be OVERLOADs on this list, too, but they
 396        are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD.  */
 397     tree names;
 398
 399     /* A list of structure, union and enum definitions, for looking up
 400        tag names.
 401        It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
 402        or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
 403        or ENUMERAL_TYPE node.
 404
 405        C++: the TREE_VALUE nodes can be simple types for
 406        component_bindings.  */
 407     tree tags;
 408
 409     /* A list of USING_DECL nodes. */
 410     tree usings;
 411
 412     /* A list of used namespaces. PURPOSE is the namespace,
 413        VALUE the common ancestor with this binding_level's namespace. */
 414     tree using_directives;
 415
 416     /* If this binding level is the binding level for a class, then
 417        class_shadowed is a TREE_LIST.  The TREE_PURPOSE of each node
 418        is the name of an entity bound in the class; the TREE_VALUE is
 419        the IDENTIFIER_CLASS_VALUE before we entered the class.  Thus,
 420        when leaving class scope, we can restore the
 421        IDENTIFIER_CLASS_VALUE by walking this list.  The TREE_TYPE is
 422        the DECL bound by this name in the class.  */
 423     tree class_shadowed;
 424
 425     /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
 426        is used for all binding levels.  */
 427     tree type_shadowed;
 428
 429     /* A TREE_LIST.  Each TREE_VALUE is the LABEL_DECL for a local
 430        label in this scope.  The TREE_PURPOSE is the previous value of
 431        the IDENTIFIER_LABEL VALUE.  */
 432     tree shadowed_labels;
 433
 434     /* For each level (except not the global one),
 435        a chain of BLOCK nodes for all the levels
 436        that were entered and exited one level down.  */
 437     tree blocks;
 438
 439     /* The BLOCK node for this level, if one has been preallocated.
 440        If 0, the BLOCK is allocated (if needed) when the level is popped.  */
 441     tree this_block;
 442
 443     /* The binding level which this one is contained in (inherits from).  */
 444     struct binding_level *level_chain;
 445
 446     /* List of decls in `names' that have incomplete
 447        structure or union types.  */
 448     tree incomplete;
 449
 450     /* List of VAR_DECLS saved from a previous for statement.
 451        These would be dead in ANSI-conforming code, but might
 452        be referenced in ARM-era code.  These are stored in a
 453        TREE_LIST; the TREE_VALUE is the actual declaration.  */
 454     tree dead_vars_from_for;
 455
 456     /* 1 for the level that holds the parameters of a function.
 457        2 for the level that holds a class declaration.
 458        3 for levels that hold parameter declarations.  */
 459     unsigned parm_flag : 4;
 460
 461     /* 1 means make a BLOCK for this level regardless of all else.
 462        2 for temporary binding contours created by the compiler.  */
 463     unsigned keep : 3;
 464
 465     /* Nonzero if this level "doesn't exist" for tags.  */
 466     unsigned tag_transparent : 1;
 467
 468     /* Nonzero if this level can safely have additional
 469        cleanup-needing variables added to it.  */
 470     unsigned more_cleanups_ok : 1;
 471     unsigned have_cleanups : 1;
 472
 473     /* Nonzero if this level is for storing the decls for template
 474        parameters and generic decls; these decls will be discarded and
 475        replaced with a TEMPLATE_DECL.  */
 476     unsigned pseudo_global : 1;
 477
 478     /* This is set for a namespace binding level.  */
 479     unsigned namespace_p : 1;
 480
 481     /* True if this level is that of a for-statement where we need to
 482        worry about ambiguous (ARM or ANSI) scope rules.  */
 483     unsigned is_for_scope : 1;
 484
 485     /* True if this level corresponds to an EH region, as for a try block.  */
 486     unsigned eh_region : 1;
 487
 488     /* One bit left for this word.  */
 489
 490 #if defined(DEBUG_CP_BINDING_LEVELS)
 491     /* Binding depth at which this level began.  */
 492     unsigned binding_depth;
 493 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 494   };
 495
 496 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
 497
 498 /* The binding level currently in effect.  */
 499
 500 #define current_binding_level                   \
 501   (current_function                             \
 502    ? cp_function_chain->bindings                \
 503    : scope_chain->bindings)
 504
 505 /* The binding level of the current class, if any.  */
 506
 507 #define class_binding_level scope_chain->class_bindings
 508
 509 /* A chain of binding_level structures awaiting reuse.  */
 510
 511 static struct binding_level *free_binding_level;
 512
 513 /* The outermost binding level, for names of file scope.
 514    This is created when the compiler is started and exists
 515    through the entire run.  */
 516
 517 static struct binding_level *global_binding_level;
 518
 519 /* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
 520
 521 static int keep_next_level_flag;
 522
 523 #if defined(DEBUG_CP_BINDING_LEVELS)
 524 static int binding_depth = 0;
 525 static int is_class_level = 0;
 526
 527 static void
 528 indent ()
 529 {
 530   register unsigned i;
 531
 532   for (i = 0; i < binding_depth*2; i++)
 533     putc (' ', stderr);
 534 }
 535 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 536
 537 static tree pushdecl_with_scope PROTO((tree, struct binding_level *));
 538
 539 static void
 540 push_binding_level (newlevel, tag_transparent, keep)
 541      struct binding_level *newlevel;
 542      int tag_transparent, keep;
 543 {
 544   /* Add this level to the front of the chain (stack) of levels that
 545      are active.  */
 546   bzero ((char*) newlevel, sizeof (struct binding_level));
 547   newlevel->level_chain = current_binding_level;
 548   current_binding_level = newlevel;
 549   newlevel->tag_transparent = tag_transparent;
 550   newlevel->more_cleanups_ok = 1;
 551
 552   /* We are called before expand_start_bindings, but after
 553      expand_eh_region_start for a try block; so we check this now,
 554      before the EH block is covered up.  */
 555   newlevel->eh_region = is_eh_region ();
 556
 557   newlevel->keep = keep;
 558 #if defined(DEBUG_CP_BINDING_LEVELS)
 559   newlevel->binding_depth = binding_depth;
 560   indent ();
 561   fprintf (stderr, "push %s level 0x%08x line %d\n",
 562            (is_class_level) ? "class" : "block", newlevel, lineno);
 563   is_class_level = 0;
 564   binding_depth++;
 565 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 566 }
 567
 568 /* Find the innermost enclosing class scope, and reset
 569    CLASS_BINDING_LEVEL appropriately.  */
 570
 571 static void
 572 find_class_binding_level ()
 573 {
 574   struct binding_level *level = current_binding_level;
 575
 576   while (level && level->parm_flag != 2)
 577     level = level->level_chain;
 578   if (level && level->parm_flag == 2)
 579     class_binding_level = level;
 580   else
 581     class_binding_level = 0;
 582 }
 583
 584 static void
 585 pop_binding_level ()
 586 {
 587   if (global_binding_level)
 588     {
 589       /* Cannot pop a level, if there are none left to pop.  */
 590       if (current_binding_level == global_binding_level)
 591         my_friendly_abort (123);
 592     }
 593   /* Pop the current level, and free the structure for reuse.  */
 594 #if defined(DEBUG_CP_BINDING_LEVELS)
 595   binding_depth--;
 596   indent ();
 597   fprintf (stderr, "pop  %s level 0x%08x line %d\n",
 598           (is_class_level) ? "class" : "block",
 599           current_binding_level, lineno);
 600   if (is_class_level != (current_binding_level == class_binding_level))
 601     {
 602       indent ();
 603       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 604     }
 605   is_class_level = 0;
 606 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 607   {
 608     register struct binding_level *level = current_binding_level;
 609     current_binding_level = current_binding_level->level_chain;
 610     level->level_chain = free_binding_level;
 611 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
 612     if (level->binding_depth != binding_depth)
 613       abort ();
 614 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 615     free_binding_level = level;
 616     find_class_binding_level ();
 617   }
 618 }
 619
 620 static void
 621 suspend_binding_level ()
 622 {
 623   if (class_binding_level)
 624     current_binding_level = class_binding_level;
 625
 626   if (global_binding_level)
 627     {
 628       /* Cannot suspend a level, if there are none left to suspend.  */
 629       if (current_binding_level == global_binding_level)
 630         my_friendly_abort (123);
 631     }
 632   /* Suspend the current level.  */
 633 #if defined(DEBUG_CP_BINDING_LEVELS)
 634   binding_depth--;
 635   indent ();
 636   fprintf (stderr, "suspend  %s level 0x%08x line %d\n",
 637           (is_class_level) ? "class" : "block",
 638           current_binding_level, lineno);
 639   if (is_class_level != (current_binding_level == class_binding_level))
 640     {
 641       indent ();
 642       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 643     }
 644   is_class_level = 0;
 645 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 646   current_binding_level = current_binding_level->level_chain;
 647   find_class_binding_level ();
 648 }
 649
 650 static void
 651 resume_binding_level (b)
 652      struct binding_level *b;
 653 {
 654   /* Resuming binding levels is meant only for namespaces,
 655      and those cannot nest into classes. */
 656   my_friendly_assert(!class_binding_level, 386);
 657   /* Also, resuming a non-directly nested namespace is a no-no.  */
 658   my_friendly_assert(b->level_chain == current_binding_level, 386);
 659   current_binding_level = b;
 660 #if defined(DEBUG_CP_BINDING_LEVELS)
 661   b->binding_depth = binding_depth;
 662   indent ();
 663   fprintf (stderr, "resume %s level 0x%08x line %d\n",
 664            (is_class_level) ? "class" : "block", b, lineno);
 665   is_class_level = 0;
 666   binding_depth++;
 667 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 668 }
 669 \f
 670 /* Create a new `struct binding_level'.  */
 671
 672 static
 673 struct binding_level *
 674 make_binding_level ()
 675 {
 676   /* NOSTRICT */
 677   return (struct binding_level *) xmalloc (sizeof (struct binding_level));
 678 }
 679
 680 /* Nonzero if we are currently in the global binding level.  */
 681
 682 int
 683 global_bindings_p ()
 684 {
 685   return current_binding_level == global_binding_level;
 686 }
 687
 688 /* Return the innermost binding level that is not for a class scope.  */
 689
 690 static struct binding_level *
 691 innermost_nonclass_level ()
 692 {
 693   struct binding_level *b;
 694
 695   b = current_binding_level;
 696   while (b->parm_flag == 2)
 697     b = b->level_chain;
 698
 699   return b;
 700 }
 701
 702 /* Nonzero if we are currently in a toplevel binding level.  This
 703    means either the global binding level or a namespace in a toplevel
 704    binding level.  Since there are no non-toplevel namespace levels,
 705    this really means any namespace or pseudo-global level.  We also
 706    include a class whose context is toplevel.  */
 707
 708 int
 709 toplevel_bindings_p ()
 710 {
 711   struct binding_level *b = innermost_nonclass_level ();
 712
 713   return b->namespace_p || b->pseudo_global;
 714 }
 715
 716 /* Nonzero if this is a namespace scope, or if we are defining a class
 717    which is itself at namespace scope, or whose enclosing class is
 718    such a class, etc.  */
 719
 720 int
 721 namespace_bindings_p ()
 722 {
 723   struct binding_level *b = innermost_nonclass_level ();
 724
 725   return b->namespace_p;
 726 }
 727
 728 /* If KEEP is non-zero, make a BLOCK node for the next binding level,
 729    unconditionally.  Otherwise, use the normal logic to decide whether
 730    or not to create a BLOCK.  */
 731
 732 void
 733 keep_next_level (keep)
 734      int keep;
 735 {
 736   keep_next_level_flag = keep;
 737 }
 738
 739 /* Nonzero if the current level needs to have a BLOCK made.  */
 740
 741 int
 742 kept_level_p ()
 743 {
 744   return (current_binding_level->blocks != NULL_TREE
 745           || current_binding_level->keep
 746           || current_binding_level->names != NULL_TREE
 747           || (current_binding_level->tags != NULL_TREE
 748               && !current_binding_level->tag_transparent));
 749 }
 750
 751 void
 752 declare_pseudo_global_level ()
 753 {
 754   current_binding_level->pseudo_global = 1;
 755 }
 756
 757 static void
 758 declare_namespace_level ()
 759 {
 760   current_binding_level->namespace_p = 1;
 761 }
 762
 763 int
 764 pseudo_global_level_p ()
 765 {
 766   return current_binding_level->pseudo_global;
 767 }
 768
 769 void
 770 set_class_shadows (shadows)
 771      tree shadows;
 772 {
 773   class_binding_level->class_shadowed = shadows;
 774 }
 775
 776 /* Enter a new binding level.
 777    If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
 778    not for that of tags.  */
 779
 780 void
 781 pushlevel (tag_transparent)
 782      int tag_transparent;
 783 {
 784   struct binding_level *newlevel;
 785
 786   if (current_function && !doing_semantic_analysis_p ())
 787     return;
 788
 789   /* Reuse or create a struct for this binding level.  */
 790 #if defined(DEBUG_CP_BINDING_LEVELS)
 791   if (0)
 792 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
 793   if (free_binding_level)
 794 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
 795     {
 796       newlevel = free_binding_level;
 797       free_binding_level = free_binding_level->level_chain;
 798     }
 799   else
 800     newlevel = make_binding_level ();
 801
 802   push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
 803   GNU_xref_start_scope ((HOST_WIDE_INT) newlevel);
 804   keep_next_level_flag = 0;
 805 }
 806
 807 void
 808 note_level_for_for ()
 809 {
 810   current_binding_level->is_for_scope = 1;
 811 }
 812
 813 /* For a binding between a name and an entity at a block scope,
 814    this is the `struct binding_level' for the block.  */
 815 #define BINDING_LEVEL(NODE) \
 816    (((struct tree_binding*)NODE)->scope.level)
 817
 818 /* Make DECL the innermost binding for ID.  The LEVEL is the binding
 819    level at which this declaration is being bound.  */
 820
 821 static void
 822 push_binding (id, decl, level)
 823      tree id;
 824      tree decl;
 825      struct binding_level* level;
 826 {
 827   tree binding;
 828
 829   binding = make_node (CPLUS_BINDING);
 830
 831   /* Now, fill in the binding information.  */
 832   BINDING_VALUE (binding) = decl;
 833   BINDING_TYPE (binding) = NULL_TREE;
 834   BINDING_LEVEL (binding) = level;
 835   INHERITED_VALUE_BINDING_P (binding) = 0;
 836   LOCAL_BINDING_P (binding) = (level != class_binding_level);
 837   BINDING_HAS_LEVEL_P (binding) = 1;
 838
 839   /* And put it on the front of the list of bindings for ID.  */
 840   TREE_CHAIN (binding) = IDENTIFIER_BINDING (id);
 841   IDENTIFIER_BINDING (id) = binding;
 842 }
 843
 844 /* ID is already bound in the current scope.  But, DECL is an
 845    additional binding for ID in the same scope.  This is the `struct
 846    stat' hack whereby a non-typedef class-name or enum-name can be
 847    bound at the same level as some other kind of entity.  It's the
 848    responsibility of the caller to check that inserting this name is
 849    legal here.  Returns nonzero if the new binding was successful.  */
 850 static int
 851 add_binding (id, decl)
 852      tree id;
 853      tree decl;
 854 {
 855   tree binding = IDENTIFIER_BINDING (id);
 856   int ok = 1;
 857
 858   if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
 859     /* The new name is the type name.  */
 860     BINDING_TYPE (binding) = decl;
 861   else if (!BINDING_VALUE (binding))
 862     /* This situation arises when push_class_level_binding moves an
 863        inherited type-binding out of the way to make room for a new
 864        value binding.  */
 865     BINDING_VALUE (binding) = decl;
 866   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
 867            && DECL_ARTIFICIAL (BINDING_VALUE (binding)))
 868     {
 869       /* The old binding was a type name.  It was placed in
 870          BINDING_VALUE because it was thought, at the point it was
 871          declared, to be the only entity with such a name.  Move the
 872          type name into the type slot; it is now hidden by the new
 873          binding.  */
 874       BINDING_TYPE (binding) = BINDING_VALUE (binding);
 875       BINDING_VALUE (binding) = decl;
 876       INHERITED_VALUE_BINDING_P (binding) = 0;
 877     }
 878   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
 879            && TREE_CODE (decl) == TYPE_DECL
 880            && DECL_NAME (decl) == DECL_NAME (BINDING_VALUE (binding))
 881            && same_type_p (TREE_TYPE (decl),
 882                            TREE_TYPE (BINDING_VALUE (binding))))
 883     /* We have two typedef-names, both naming the same type to have
 884        the same name.  This is OK because of:
 885
 886          [dcl.typedef]
 887
 888          In a given scope, a typedef specifier can be used to redefine
 889          the name of any type declared in that scope to refer to the
 890          type to which it already refers.  */
 891     ok = 0;
 892   else
 893     {
 894       cp_error ("declaration of `%#D'", decl);
 895       cp_error_at ("conflicts with previous declaration `%#D'",
 896                    BINDING_VALUE (binding));
 897       ok = 0;
 898     }
 899
 900   return ok;
 901 }
 902
 903 /* Add DECL to the list of things declared in B.  */
 904
 905 static void
 906 add_decl_to_level (decl, b)
 907      tree decl;
 908      struct binding_level *b;
 909 {
 910   /* We build up the list in reverse order, and reverse it later if
 911      necessary.  */
 912   TREE_CHAIN (decl) = b->names;
 913   b->names = decl;
 914 }
 915
 916 /* Bind DECL to ID in the current_binding_level, assumed to be a local
 917    binding level.  If PUSH_USING is set in FLAGS, we know that DECL
 918    doesn't really belong to this binding level, that it got here
 919    through a using-declaration.  */
 920
 921 void
 922 push_local_binding (id, decl, flags)
 923      tree id;
 924      tree decl;
 925      int flags;
 926 {
 927   struct binding_level *b;
 928
 929   /* Skip over any local classes.  This makes sense if we call
 930      push_local_binding with a friend decl of a local class.  */
 931   b = current_binding_level;
 932   while (b->parm_flag == 2)
 933     b = b->level_chain;
 934
 935   if (lookup_name_current_level (id))
 936     {
 937       /* Supplement the existing binding.  */
 938       if (!add_binding (id, decl))
 939         /* It didn't work.  Something else must be bound at this
 940            level.  Do not add DECL to the list of things to pop
 941            later.  */
 942         return;
 943     }
 944   else
 945     /* Create a new binding.  */
 946     push_binding (id, decl, b);
 947
 948   if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
 949     /* We must put the OVERLOAD into a TREE_LIST since the
 950        TREE_CHAIN of an OVERLOAD is already used.  Similarly for
 951        decls that got here through a using-declaration.  */
 952     decl = build_tree_list (NULL_TREE, decl);
 953
 954   /* And put DECL on the list of things declared by the current
 955      binding level.  */
 956   add_decl_to_level (decl, b);
 957 }
 958
 959 /* Bind DECL to ID in the class_binding_level.  Returns nonzero if the
 960    binding was successful.  */
 961
 962 int
 963 push_class_binding (id, decl)
 964      tree id;
 965      tree decl;
 966 {
 967   int result = 1;
 968   tree binding = IDENTIFIER_BINDING (id);
 969   tree context;
 970
 971   /* Note that we declared this value so that we can issue an error if
 972      this an illegal redeclaration of a name already used for some
 973      other purpose.  */
 974   note_name_declared_in_class (id, decl);
 975
 976   if (binding && BINDING_LEVEL (binding) == class_binding_level)
 977     /* Supplement the existing binding.  */
 978     result = add_binding (id, decl);
 979   else
 980     /* Create a new binding.  */
 981     push_binding (id, decl, class_binding_level);
 982
 983   /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
 984      class-level declaration.  Note that we do not use DECL here
 985      because of the possibility of the `struct stat' hack; if DECL is
 986      a class-name or enum-name we might prefer a field-name, or some
 987      such.  */
 988   IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
 989
 990   /* If this is a binding from a base class, mark it as such.  */
 991   binding = IDENTIFIER_BINDING (id);
 992   if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
 993     {
 994       /* Any implicit typename must be from a base-class.  The
 995          context for an implicit typename declaration is always
 996          the derived class in which the lookup was done, so the checks
 997          based on the context of DECL below will not trigger.  */
 998       if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl))
 999         INHERITED_VALUE_BINDING_P (binding) = 1;
1000       else
1001         {
1002           if (TREE_CODE (decl) == OVERLOAD)
1003             context = DECL_REAL_CONTEXT (OVL_CURRENT (decl));
1004           else
1005             {
1006               my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (decl)) == 'd',
1007                                   0);
1008               context = DECL_REAL_CONTEXT (decl);
1009             }
1010
1011           if (is_properly_derived_from (current_class_type, context))
1012             INHERITED_VALUE_BINDING_P (binding) = 1;
1013           else
1014             INHERITED_VALUE_BINDING_P (binding) = 0;
1015         }
1016     }
1017   else if (BINDING_VALUE (binding) == decl)
1018     /* We only encounter a TREE_LIST when push_class_decls detects an
1019        ambiguity.  Such an ambiguity can be overridden by a definition
1020        in this class.  */
1021     INHERITED_VALUE_BINDING_P (binding) = 1;
1022
1023   return result;
1024 }
1025
1026 /* Remove the binding for DECL which should be the innermost binding
1027    for ID.  */
1028
1029 static void
1030 pop_binding (id, decl)
1031      tree id;
1032      tree decl;
1033 {
1034   tree binding;
1035
1036   if (id == NULL_TREE)
1037     /* It's easiest to write the loops that call this function without
1038        checking whether or not the entities involved have names.  We
1039        get here for such an entity.  */
1040     return;
1041
1042   /* Get the innermost binding for ID.  */
1043   binding = IDENTIFIER_BINDING (id);
1044
1045   /* The name should be bound.  */
1046   my_friendly_assert (binding != NULL_TREE, 0);
1047
1048   /* The DECL will be either the ordinary binding or the type
1049      binding for this identifier.  Remove that binding.  */
1050   if (BINDING_VALUE (binding) == decl)
1051     BINDING_VALUE (binding) = NULL_TREE;
1052   else if (BINDING_TYPE (binding) == decl)
1053     BINDING_TYPE (binding) = NULL_TREE;
1054   else
1055     my_friendly_abort (0);
1056
1057   if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
1058     /* We're completely done with the innermost binding for this
1059        identifier.  Unhook it from the list of bindings.  */
1060     IDENTIFIER_BINDING (id) = TREE_CHAIN (binding);
1061 }
1062
1063 /* When a label goes out of scope, check to see if that label was used
1064    in a valid manner, and issue any appropriate warnings or errors.  */
1065
1066 static void
1067 pop_label (link)
1068      tree link;
1069 {
1070   tree label = TREE_VALUE (link);
1071
1072   if (!processing_template_decl && doing_semantic_analysis_p ())
1073     {
1074       if (DECL_INITIAL (label) == NULL_TREE)
1075         {
1076           cp_error_at ("label `%D' used but not defined", label);
1077           /* Avoid crashing later.  */
1078           define_label (input_filename, 1, DECL_NAME (label));
1079         }
1080       else if (warn_unused && !TREE_USED (label))
1081         cp_warning_at ("label `%D' defined but not used", label);
1082     }
1083
1084   SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), TREE_PURPOSE (link));
1085 }
1086
1087 /* At the end of a function, all labels declared within the fucntion
1088    go out of scope.  BLOCK is the top-level block for the
1089    function.  */
1090
1091 static void
1092 pop_labels (block)
1093      tree block;
1094 {
1095   tree link;
1096
1097   /* Clear out the definitions of all label names, since their scopes
1098      end here.  */
1099   for (link = named_labels; link; link = TREE_CHAIN (link))
1100     {
1101       pop_label (link);
1102       /* Put the labels into the "variables" of the top-level block,
1103          so debugger can see them.  */
1104       TREE_CHAIN (TREE_VALUE (link)) = BLOCK_VARS (block);
1105       BLOCK_VARS (block) = TREE_VALUE (link);
1106     }
1107
1108   named_labels = NULL_TREE;
1109 }
1110
1111 /* Exit a binding level.
1112    Pop the level off, and restore the state of the identifier-decl mappings
1113    that were in effect when this level was entered.
1114
1115    If KEEP == 1, this level had explicit declarations, so
1116    and create a "block" (a BLOCK node) for the level
1117    to record its declarations and subblocks for symbol table output.
1118
1119    If FUNCTIONBODY is nonzero, this level is the body of a function,
1120    so create a block as if KEEP were set and also clear out all
1121    label names.
1122
1123    If REVERSE is nonzero, reverse the order of decls before putting
1124    them into the BLOCK.  */
1125
1126 tree
1127 poplevel (keep, reverse, functionbody)
1128      int keep;
1129      int reverse;
1130      int functionbody;
1131 {
1132   register tree link;
1133   /* The chain of decls was accumulated in reverse order.
1134      Put it into forward order, just for cleanliness.  */
1135   tree decls;
1136   int tmp = functionbody;
1137   int real_functionbody;
1138   tree tags;
1139   tree subblocks;
1140   tree block = NULL_TREE;
1141   tree decl;
1142   int block_previously_created;
1143   int leaving_for_scope;
1144
1145   if (current_function && !doing_semantic_analysis_p ())
1146     return NULL_TREE;
1147
1148   my_friendly_assert (current_binding_level->parm_flag != 2,
1149                       19990916);
1150
1151   real_functionbody = (current_binding_level->keep == 2
1152                        ? ((functionbody = 0), tmp) : functionbody);
1153   tags = functionbody >= 0 ? current_binding_level->tags : 0;
1154   subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1155
1156   my_friendly_assert (!current_binding_level->class_shadowed,
1157                       19990414);
1158
1159   /* We used to use KEEP == 2 to indicate that the new block should go
1160      at the beginning of the list of blocks at this binding level,
1161      rather than the end.  This hack is no longer used.  */
1162   my_friendly_assert (keep == 0 || keep == 1, 0);
1163
1164   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
1165                       (HOST_WIDE_INT) current_binding_level->level_chain,
1166                       current_binding_level->parm_flag,
1167                       current_binding_level->keep);
1168
1169   if (current_binding_level->keep == 1)
1170     keep = 1;
1171
1172   /* Get the decls in the order they were written.
1173      Usually current_binding_level->names is in reverse order.
1174      But parameter decls were previously put in forward order.  */
1175
1176   if (reverse)
1177     current_binding_level->names
1178       = decls = nreverse (current_binding_level->names);
1179   else
1180     decls = current_binding_level->names;
1181
1182   /* Output any nested inline functions within this block
1183      if they weren't already output.  */
1184
1185   for (decl = decls; decl; decl = TREE_CHAIN (decl))
1186     if (TREE_CODE (decl) == FUNCTION_DECL
1187         && ! TREE_ASM_WRITTEN (decl)
1188         && DECL_INITIAL (decl) != NULL_TREE
1189         && TREE_ADDRESSABLE (decl)
1190         && decl_function_context (decl) == current_function_decl)
1191       {
1192         /* If this decl was copied from a file-scope decl
1193            on account of a block-scope extern decl,
1194            propagate TREE_ADDRESSABLE to the file-scope decl.  */
1195         if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1196           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1197         else
1198           {
1199             push_function_context ();
1200             output_inline_function (decl);
1201             pop_function_context ();
1202           }
1203       }
1204
1205   /* If there were any declarations or structure tags in that level,
1206      or if this level is a function body,
1207      create a BLOCK to record them for the life of this function.  */
1208
1209   block = NULL_TREE;
1210   block_previously_created = (current_binding_level->this_block != NULL_TREE);
1211   if (block_previously_created)
1212     block = current_binding_level->this_block;
1213   else if (keep == 1 || functionbody)
1214     block = make_node (BLOCK);
1215   if (block != NULL_TREE)
1216     {
1217       if (block_previously_created)
1218         {
1219           if (decls || tags || subblocks)
1220             {
1221               if (BLOCK_VARS (block))
1222                 warning ("internal compiler error: debugging info corrupted");
1223
1224               BLOCK_VARS (block) = decls;
1225
1226               /* We can have previous subblocks and new subblocks when
1227                  doing fixup_gotos with complex cleanups.  We chain the new
1228                  subblocks onto the end of any pre-existing subblocks.  */
1229               BLOCK_SUBBLOCKS (block) = chainon (BLOCK_SUBBLOCKS (block),
1230                                                  subblocks);
1231             }
1232         }
1233       else
1234         {
1235           BLOCK_VARS (block) = decls;
1236           BLOCK_SUBBLOCKS (block) = subblocks;
1237         }
1238     }
1239
1240   /* In each subblock, record that this is its superior.  */
1241
1242   if (keep >= 0)
1243     for (link = subblocks; link; link = TREE_CHAIN (link))
1244       BLOCK_SUPERCONTEXT (link) = block;
1245
1246   /* We still support the old for-scope rules, whereby the variables
1247      in a for-init statement were in scope after the for-statement
1248      ended.  We only use the new rules in flag_new_for_scope is
1249      nonzero.  */
1250   leaving_for_scope
1251     = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1252
1253   /* Remove declarations for all the DECLs in this level.  */
1254   for (link = decls; link; link = TREE_CHAIN (link))
1255     {
1256       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL)
1257         {
1258           tree outer_binding
1259             = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1260           tree ns_binding;
1261
1262           if (!outer_binding)
1263             ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1264           else
1265             ns_binding = NULL_TREE;
1266
1267           if (outer_binding
1268               && (BINDING_LEVEL (outer_binding)
1269                   == current_binding_level->level_chain))
1270             /* We have something like:
1271
1272                  int i;
1273                  for (int i; ;);
1274
1275                and we are leaving the `for' scope.  There's no reason to
1276                keep the binding of the inner `i' in this case.  */
1277             pop_binding (DECL_NAME (link), link);
1278           else if ((outer_binding
1279                     && (TREE_CODE (BINDING_VALUE (outer_binding))
1280                         == TYPE_DECL))
1281                    || (ns_binding
1282                        && TREE_CODE (ns_binding) == TYPE_DECL))
1283             /* Here, we have something like:
1284
1285                  typedef int I;
1286
1287                  void f () {
1288                    for (int I; ;);
1289                  }
1290
1291                We must pop the for-scope binding so we know what's a
1292                type and what isn't.  */
1293             pop_binding (DECL_NAME (link), link);
1294           else
1295             {
1296               /* Mark this VAR_DECL as dead so that we can tell we left it
1297                  there only for backward compatibility.  */
1298               DECL_DEAD_FOR_LOCAL (link) = 1;
1299
1300               /* Keep track of what should of have happenned when we
1301                  popped the binding.  */
1302               if (outer_binding && BINDING_VALUE (outer_binding))
1303                 DECL_SHADOWED_FOR_VAR (link)
1304                   = BINDING_VALUE (outer_binding);
1305
1306               /* Add it to the list of dead variables in the next
1307                  outermost binding to that we can remove these when we
1308                  leave that binding.  */
1309               current_binding_level->level_chain->dead_vars_from_for
1310                 = tree_cons (NULL_TREE, link,
1311                              current_binding_level->level_chain->
1312                              dead_vars_from_for);
1313
1314               /* Although we don't pop the CPLUS_BINDING, we do clear
1315                  its BINDING_LEVEL since the level is going away now.  */
1316               BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1317                 = 0;
1318             }
1319         }
1320       else
1321         {
1322           /* Remove the binding.  */
1323           decl = link;
1324           if (TREE_CODE (decl) == TREE_LIST)
1325             decl = TREE_VALUE (decl);
1326           if (TREE_CODE_CLASS (TREE_CODE (decl)) == 'd')
1327             pop_binding (DECL_NAME (decl), decl);
1328           else if (TREE_CODE (decl) == OVERLOAD)
1329             pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1330           else
1331             my_friendly_abort (0);
1332         }
1333     }
1334
1335   /* Remove declarations for any `for' variables from inner scopes
1336      that we kept around.  */
1337   for (link = current_binding_level->dead_vars_from_for;
1338        link; link = TREE_CHAIN (link))
1339     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1340
1341   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
1342   for (link = current_binding_level->type_shadowed;
1343        link; link = TREE_CHAIN (link))
1344     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1345
1346   /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
1347   for (link = current_binding_level->shadowed_labels;
1348        link;
1349        link = TREE_CHAIN (link))
1350     pop_label (link);
1351
1352   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1353      list if a `using' declaration put them there.  The debugging
1354      back-ends won't understand OVERLOAD, so we remove them here.
1355      Because the BLOCK_VARS are (temporarily) shared with
1356      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1357      popped all the bindings.  */
1358   if (block)
1359     {
1360       tree* d;
1361
1362       for (d = &BLOCK_VARS (block); *d; )
1363         {
1364           if (TREE_CODE (*d) == TREE_LIST)
1365             *d = TREE_CHAIN (*d);
1366           else
1367             d = &TREE_CHAIN (*d);
1368         }
1369     }
1370
1371   /* If the level being exited is the top level of a function,
1372      check over all the labels.  */
1373   if (functionbody)
1374     {
1375       /* Since this is the top level block of a function, the vars are
1376          the function's parameters.  Don't leave them in the BLOCK
1377          because they are found in the FUNCTION_DECL instead.  */
1378       BLOCK_VARS (block) = 0;
1379       pop_labels (block);
1380     }
1381
1382   /* Any uses of undefined labels now operate under constraints
1383      of next binding contour.  */
1384   if (current_function)
1385     {
1386       struct binding_level *level_chain;
1387       level_chain = current_binding_level->level_chain;
1388       if (level_chain)
1389         {
1390           struct named_label_list *labels;
1391           for (labels = named_label_uses; labels; labels = labels->next)
1392             if (labels->binding_level == current_binding_level)
1393               {
1394                 labels->binding_level = level_chain;
1395                 labels->names_in_scope = level_chain->names;
1396               }
1397         }
1398     }
1399
1400   tmp = current_binding_level->keep;
1401
1402   pop_binding_level ();
1403   if (functionbody)
1404     DECL_INITIAL (current_function_decl) = block;
1405   else if (block)
1406     {
1407       if (!block_previously_created)
1408         current_binding_level->blocks
1409           = chainon (current_binding_level->blocks, block);
1410     }
1411   /* If we did not make a block for the level just exited,
1412      any blocks made for inner levels
1413      (since they cannot be recorded as subblocks in that level)
1414      must be carried forward so they will later become subblocks
1415      of something else.  */
1416   else if (subblocks)
1417     current_binding_level->blocks
1418       = chainon (current_binding_level->blocks, subblocks);
1419
1420   /* Take care of compiler's internal binding structures.  */
1421   if (tmp == 2)
1422     {
1423       add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1424       /* Each and every BLOCK node created here in `poplevel' is important
1425          (e.g. for proper debugging information) so if we created one
1426          earlier, mark it as "used".  */
1427       if (block)
1428         TREE_USED (block) = 1;
1429       block = poplevel (keep, reverse, functionbody);
1430     }
1431
1432   /* Each and every BLOCK node created here in `poplevel' is important
1433      (e.g. for proper debugging information) so if we created one
1434      earlier, mark it as "used".  */
1435   if (block)
1436     TREE_USED (block) = 1;
1437   return block;
1438 }
1439
1440 /* Delete the node BLOCK from the current binding level.
1441    This is used for the block inside a stmt expr ({...})
1442    so that the block can be reinserted where appropriate.  */
1443
1444 void
1445 delete_block (block)
1446      tree block;
1447 {
1448   tree t;
1449   if (current_binding_level->blocks == block)
1450     current_binding_level->blocks = TREE_CHAIN (block);
1451   for (t = current_binding_level->blocks; t;)
1452     {
1453       if (TREE_CHAIN (t) == block)
1454         TREE_CHAIN (t) = TREE_CHAIN (block);
1455       else
1456         t = TREE_CHAIN (t);
1457     }
1458   TREE_CHAIN (block) = NULL_TREE;
1459   /* Clear TREE_USED which is always set by poplevel.
1460      The flag is set again if insert_block is called.  */
1461   TREE_USED (block) = 0;
1462 }
1463
1464 /* Insert BLOCK at the end of the list of subblocks of the
1465    current binding level.  This is used when a BIND_EXPR is expanded,
1466    to handle the BLOCK node inside the BIND_EXPR.  */
1467
1468 void
1469 insert_block (block)
1470      tree block;
1471 {
1472   TREE_USED (block) = 1;
1473   current_binding_level->blocks
1474     = chainon (current_binding_level->blocks, block);
1475 }
1476
1477 /* Set the BLOCK node for the innermost scope
1478    (the one we are currently in).  */
1479
1480 void
1481 set_block (block)
1482     register tree block;
1483 {
1484   current_binding_level->this_block = block;
1485 }
1486
1487 /* Do a pushlevel for class declarations.  */
1488
1489 void
1490 pushlevel_class ()
1491 {
1492   register struct binding_level *newlevel;
1493
1494   /* Reuse or create a struct for this binding level.  */
1495 #if defined(DEBUG_CP_BINDING_LEVELS)
1496   if (0)
1497 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1498   if (free_binding_level)
1499 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1500     {
1501       newlevel = free_binding_level;
1502       free_binding_level = free_binding_level->level_chain;
1503     }
1504   else
1505     newlevel = make_binding_level ();
1506
1507 #if defined(DEBUG_CP_BINDING_LEVELS)
1508   is_class_level = 1;
1509 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1510
1511   push_binding_level (newlevel, 0, 0);
1512
1513   class_binding_level = current_binding_level;
1514   class_binding_level->parm_flag = 2;
1515 }
1516
1517 /* ...and a poplevel for class declarations.  */
1518
1519 void
1520 poplevel_class ()
1521 {
1522   register struct binding_level *level = class_binding_level;
1523   tree shadowed;
1524
1525   my_friendly_assert (level != 0, 354);
1526
1527   /* If we're leaving a toplevel class, don't bother to do the setting
1528      of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1529      shouldn't even be used when current_class_type isn't set, and second,
1530      if we don't touch it here, we're able to use the cache effect if the
1531      next time we're entering a class scope, it is the same class.  */
1532   if (current_class_depth != 1)
1533     {
1534       struct binding_level* b;
1535
1536       /* Clear out our IDENTIFIER_CLASS_VALUEs.  */
1537       for (shadowed = level->class_shadowed;
1538            shadowed;
1539            shadowed = TREE_CHAIN (shadowed))
1540         IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1541
1542       /* Find the next enclosing class, and recreate
1543          IDENTIFIER_CLASS_VALUEs appropriate for that class.  */
1544       b = level->level_chain;
1545       while (b && b->parm_flag != 2)
1546         b = b->level_chain;
1547
1548       if (b)
1549         for (shadowed = b->class_shadowed;
1550              shadowed;
1551              shadowed = TREE_CHAIN (shadowed))
1552           {
1553             tree t;
1554
1555             t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1556             while (t && BINDING_LEVEL (t) != b)
1557               t = TREE_CHAIN (t);
1558
1559             if (t)
1560               IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1561                 = BINDING_VALUE (t);
1562           }
1563     }
1564   else
1565     /* Remember to save what IDENTIFIER's were bound in this scope so we
1566        can recover from cache misses.  */
1567     {
1568       previous_class_type = current_class_type;
1569       previous_class_values = class_binding_level->class_shadowed;
1570     }
1571   for (shadowed = level->type_shadowed;
1572        shadowed;
1573        shadowed = TREE_CHAIN (shadowed))
1574     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1575
1576   /* Remove the bindings for all of the class-level declarations.  */
1577   for (shadowed = level->class_shadowed;
1578        shadowed;
1579        shadowed = TREE_CHAIN (shadowed))
1580     pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1581
1582   GNU_xref_end_scope ((HOST_WIDE_INT) class_binding_level,
1583                       (HOST_WIDE_INT) class_binding_level->level_chain,
1584                       class_binding_level->parm_flag,
1585                       class_binding_level->keep);
1586
1587   /* Now, pop out of the binding level which we created up in the
1588      `pushlevel_class' routine.  */
1589 #if defined(DEBUG_CP_BINDING_LEVELS)
1590   is_class_level = 1;
1591 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1592
1593   pop_binding_level ();
1594 }
1595
1596 /* We are entering the scope of a class.  Clear IDENTIFIER_CLASS_VALUE
1597    for any names in enclosing classes.  */
1598
1599 void
1600 clear_identifier_class_values ()
1601 {
1602   tree t;
1603
1604   if (!class_binding_level)
1605     return;
1606
1607   for (t = class_binding_level->class_shadowed;
1608        t;
1609        t = TREE_CHAIN (t))
1610     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1611 }
1612
1613 /* Returns non-zero if T is a virtual function table.  */
1614
1615 int
1616 vtable_decl_p (t, data)
1617      tree t;
1618      void *data ATTRIBUTE_UNUSED;
1619 {
1620   return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1621 }
1622
1623 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1624    functions.  */
1625
1626 int
1627 vtype_decl_p (t, data)
1628      tree t;
1629      void *data ATTRIBUTE_UNUSED;
1630 {
1631   return (TREE_CODE (t) == TYPE_DECL
1632           && TREE_TYPE (t) != error_mark_node
1633           && TYPE_LANG_SPECIFIC (TREE_TYPE (t))
1634           && CLASSTYPE_VSIZE (TREE_TYPE (t)));
1635 }
1636
1637 /* Return the declarations that are members of the namespace NS.  */
1638
1639 tree
1640 cp_namespace_decls (ns)
1641      tree ns;
1642 {
1643   return NAMESPACE_LEVEL (ns)->names;
1644 }
1645
1646 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1647    itself, calling F for each.  The DATA is passed to F as well.  */
1648
1649 static int
1650 walk_namespaces_r (namespace, f, data)
1651      tree namespace;
1652      walk_namespaces_fn f;
1653      void *data;
1654 {
1655   tree current;
1656   int result = 0;
1657
1658   result |= (*f) (namespace, data);
1659
1660   for (current = cp_namespace_decls (namespace);
1661        current;
1662        current = TREE_CHAIN (current))
1663     {
1664       if (TREE_CODE (current) != NAMESPACE_DECL
1665           || DECL_NAMESPACE_ALIAS (current))
1666         continue;
1667       if (!DECL_LANG_SPECIFIC (current))
1668         {
1669           /* Hmm. std. */
1670           my_friendly_assert (current == std_node, 393);
1671           continue;
1672         }
1673
1674       /* We found a namespace.  */
1675       result |= walk_namespaces_r (current, f, data);
1676     }
1677
1678   return result;
1679 }
1680
1681 /* Walk all the namespaces, calling F for each.  The DATA is passed to
1682    F as well.  */
1683
1684 int
1685 walk_namespaces (f, data)
1686      walk_namespaces_fn f;
1687      void *data;
1688 {
1689   return walk_namespaces_r (global_namespace, f, data);
1690 }
1691
1692 struct walk_globals_data {
1693   walk_globals_pred p;
1694   walk_globals_fn f;
1695   void *data;
1696 };
1697
1698 /* Walk the global declarations in NAMESPACE.  Whenever one is found
1699    for which P returns non-zero, call F with its address.  If any call
1700    to F returns a non-zero value, return a non-zero value.  */
1701
1702 static int
1703 walk_globals_r (namespace, data)
1704      tree namespace;
1705      void *data;
1706 {
1707   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1708   walk_globals_pred p = wgd->p;
1709   walk_globals_fn f = wgd->f;
1710   void *d = wgd->data;
1711   tree *t;
1712   int result = 0;
1713
1714   t = &NAMESPACE_LEVEL (namespace)->names;
1715
1716   while (*t)
1717     {
1718       tree glbl = *t;
1719
1720       if ((*p) (glbl, d))
1721         result |= (*f) (t, d);
1722
1723       /* If F changed *T, then *T still points at the next item to
1724          examine.  */
1725       if (*t == glbl)
1726         t = &TREE_CHAIN (*t);
1727     }
1728
1729   return result;
1730 }
1731
1732 /* Walk the global declarations.  Whenever one is found for which P
1733    returns non-zero, call F with its address.  If any call to F
1734    returns a non-zero value, return a non-zero value.  */
1735
1736 int
1737 walk_globals (p, f, data)
1738      walk_globals_pred p;
1739      walk_globals_fn f;
1740      void *data;
1741 {
1742   struct walk_globals_data wgd;
1743   wgd.p = p;
1744   wgd.f = f;
1745   wgd.data = data;
1746
1747   return walk_namespaces (walk_globals_r, &wgd);
1748 }
1749
1750 /* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
1751    DATA is non-NULL, this is the last time we will call
1752    wrapup_global_declarations for this NAMESPACE.  */
1753
1754 int
1755 wrapup_globals_for_namespace (namespace, data)
1756      tree namespace;
1757      void *data;
1758 {
1759   tree globals = cp_namespace_decls (namespace);
1760   int len = list_length (globals);
1761   tree *vec = (tree *) alloca (sizeof (tree) * len);
1762   int i;
1763   int result;
1764   tree decl;
1765   int last_time = (data != 0);
1766
1767   if (last_time && namespace == global_namespace)
1768     /* Let compile_file handle the global namespace.  */
1769     return 0;
1770
1771   /* Process the decls in reverse order--earliest first.
1772      Put them into VEC from back to front, then take out from front.  */
1773
1774   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1775     vec[len - i - 1] = decl;
1776
1777   if (last_time)
1778     {
1779       check_global_declarations (vec, len);
1780       return 0;
1781     }
1782
1783   /* Temporarily mark vtables as external.  That prevents
1784      wrapup_global_declarations from writing them out; we must process
1785      them ourselves in finish_vtable_vardecl.  */
1786   for (i = 0; i < len; ++i)
1787     if (vtable_decl_p (vec[i], /*data=*/0) && !DECL_EXTERNAL (vec[i]))
1788       {
1789         DECL_NOT_REALLY_EXTERN (vec[i]) = 1;
1790         DECL_EXTERNAL (vec[i]) = 1;
1791       }
1792
1793   /* Write out any globals that need to be output.  */
1794   result = wrapup_global_declarations (vec, len);
1795
1796   /* Undo the hack to DECL_EXTERNAL above.  */
1797   for (i = 0; i < len; ++i)
1798     if (vtable_decl_p (vec[i], /*data=*/0)
1799         && DECL_NOT_REALLY_EXTERN (vec[i]))
1800       {
1801         DECL_NOT_REALLY_EXTERN (vec[i]) = 0;
1802         DECL_EXTERNAL (vec[i]) = 0;
1803       }
1804
1805   return result;
1806 }
1807
1808 \f
1809 /* Mark ARG (which is really a struct binding_level **) for GC.  */
1810
1811 static void
1812 mark_binding_level (arg)
1813      void *arg;
1814 {
1815   struct binding_level *lvl = *(struct binding_level **)arg;
1816
1817   while (lvl)
1818     {
1819       ggc_mark_tree (lvl->names);
1820       ggc_mark_tree (lvl->tags);
1821       ggc_mark_tree (lvl->usings);
1822       ggc_mark_tree (lvl->using_directives);
1823       ggc_mark_tree (lvl->class_shadowed);
1824       ggc_mark_tree (lvl->type_shadowed);
1825       ggc_mark_tree (lvl->shadowed_labels);
1826       ggc_mark_tree (lvl->blocks);
1827       ggc_mark_tree (lvl->this_block);
1828       ggc_mark_tree (lvl->incomplete);
1829       ggc_mark_tree (lvl->dead_vars_from_for);
1830
1831       lvl = lvl->level_chain;
1832     }
1833 }
1834 \f
1835 /* For debugging.  */
1836 static int no_print_functions = 0;
1837 static int no_print_builtins = 0;
1838
1839 void
1840 print_binding_level (lvl)
1841      struct binding_level *lvl;
1842 {
1843   tree t;
1844   int i = 0, len;
1845   fprintf (stderr, " blocks=");
1846   fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
1847   fprintf (stderr, " n_incomplete=%d parm_flag=%d keep=%d",
1848            list_length (lvl->incomplete), lvl->parm_flag, lvl->keep);
1849   if (lvl->tag_transparent)
1850     fprintf (stderr, " tag-transparent");
1851   if (lvl->more_cleanups_ok)
1852     fprintf (stderr, " more-cleanups-ok");
1853   if (lvl->have_cleanups)
1854     fprintf (stderr, " have-cleanups");
1855   fprintf (stderr, "\n");
1856   if (lvl->names)
1857     {
1858       fprintf (stderr, " names:\t");
1859       /* We can probably fit 3 names to a line?  */
1860       for (t = lvl->names; t; t = TREE_CHAIN (t))
1861         {
1862           if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1863             continue;
1864           if (no_print_builtins
1865               && (TREE_CODE (t) == TYPE_DECL)
1866               && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
1867             continue;
1868
1869           /* Function decls tend to have longer names.  */
1870           if (TREE_CODE (t) == FUNCTION_DECL)
1871             len = 3;
1872           else
1873             len = 2;
1874           i += len;
1875           if (i > 6)
1876             {
1877               fprintf (stderr, "\n\t");
1878               i = len;
1879             }
1880           print_node_brief (stderr, "", t, 0);
1881           if (t == error_mark_node)
1882             break;
1883         }
1884       if (i)
1885         fprintf (stderr, "\n");
1886     }
1887   if (lvl->tags)
1888     {
1889       fprintf (stderr, " tags:\t");
1890       i = 0;
1891       for (t = lvl->tags; t; t = TREE_CHAIN (t))
1892         {
1893           if (TREE_PURPOSE (t) == NULL_TREE)
1894             len = 3;
1895           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
1896             len = 2;
1897           else
1898             len = 4;
1899           i += len;
1900           if (i > 5)
1901             {
1902               fprintf (stderr, "\n\t");
1903               i = len;
1904             }
1905           if (TREE_PURPOSE (t) == NULL_TREE)
1906             {
1907               print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
1908               fprintf (stderr, ">");
1909             }
1910           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
1911             print_node_brief (stderr, "", TREE_VALUE (t), 0);
1912           else
1913             {
1914               print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
1915               print_node_brief (stderr, "", TREE_VALUE (t), 0);
1916               fprintf (stderr, ">");
1917             }
1918         }
1919       if (i)
1920         fprintf (stderr, "\n");
1921     }
1922   if (lvl->class_shadowed)
1923     {
1924       fprintf (stderr, " class-shadowed:");
1925       for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
1926         {
1927           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1928         }
1929       fprintf (stderr, "\n");
1930     }
1931   if (lvl->type_shadowed)
1932     {
1933       fprintf (stderr, " type-shadowed:");
1934       for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1935         {
1936           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1937         }
1938       fprintf (stderr, "\n");
1939     }
1940 }
1941
1942 void
1943 print_other_binding_stack (stack)
1944      struct binding_level *stack;
1945 {
1946   struct binding_level *level;
1947   for (level = stack; level != global_binding_level; level = level->level_chain)
1948     {
1949       fprintf (stderr, "binding level ");
1950       fprintf (stderr, HOST_PTR_PRINTF, level);
1951       fprintf (stderr, "\n");
1952       print_binding_level (level);
1953     }
1954 }
1955
1956 void
1957 print_binding_stack ()
1958 {
1959   struct binding_level *b;
1960   fprintf (stderr, "current_binding_level=");
1961   fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
1962   fprintf (stderr, "\nclass_binding_level=");
1963   fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
1964   fprintf (stderr, "\nglobal_binding_level=");
1965   fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
1966   fprintf (stderr, "\n");
1967   if (class_binding_level)
1968     {
1969       for (b = class_binding_level; b; b = b->level_chain)
1970         if (b == current_binding_level)
1971           break;
1972       if (b)
1973         b = class_binding_level;
1974       else
1975         b = current_binding_level;
1976     }
1977   else
1978     b = current_binding_level;
1979   print_other_binding_stack (b);
1980   fprintf (stderr, "global:\n");
1981   print_binding_level (global_binding_level);
1982 }
1983
1984 /* Namespace binding access routines: The namespace_bindings field of
1985    the identifier is polymorphic, with three possible values:
1986    NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
1987    indicating the BINDING_VALUE of global_namespace. */
1988
1989 /* Check whether the a binding for the name to scope is known.
1990    Assumes that the bindings of the name are already a list
1991    of bindings. Returns the binding found, or NULL_TREE. */
1992
1993 static tree
1994 find_binding (name, scope)
1995      tree name;
1996      tree scope;
1997 {
1998   tree iter, prev = NULL_TREE;
1999
2000   scope = ORIGINAL_NAMESPACE (scope);
2001
2002   for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2003        iter = TREE_CHAIN (iter))
2004     {
2005       my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2006       if (BINDING_SCOPE (iter) == scope)
2007         {
2008           /* Move binding found to the front of the list, so
2009              subsequent lookups will find it faster. */
2010           if (prev)
2011             {
2012               TREE_CHAIN (prev) = TREE_CHAIN (iter);
2013               TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2014               IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2015             }
2016           return iter;
2017         }
2018       prev = iter;
2019     }
2020   return NULL_TREE;
2021 }
2022
2023 /* Always returns a binding for name in scope. If the
2024    namespace_bindings is not a list, convert it to one first.
2025    If no binding is found, make a new one. */
2026
2027 tree
2028 binding_for_name (name, scope)
2029      tree name;
2030      tree scope;
2031 {
2032   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2033   tree result;
2034
2035   scope = ORIGINAL_NAMESPACE (scope);
2036
2037   if (b && TREE_CODE (b) != CPLUS_BINDING)
2038     {
2039       /* Get rid of optimization for global scope. */
2040       IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2041       BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2042       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2043     }
2044   if (b && (result = find_binding (name, scope)))
2045     return result;
2046   /* Not found, make a new permanent one. */
2047   push_obstacks (&permanent_obstack, &permanent_obstack);
2048   result = make_node (CPLUS_BINDING);
2049   TREE_CHAIN (result) = b;
2050   IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2051   BINDING_SCOPE (result) = scope;
2052   BINDING_TYPE (result) = NULL_TREE;
2053   BINDING_VALUE (result) = NULL_TREE;
2054   pop_obstacks ();
2055   return result;
2056 }
2057
2058 /* Return the binding value for name in scope, considering that
2059    namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2060
2061 tree
2062 namespace_binding (name, scope)
2063      tree name;
2064      tree scope;
2065 {
2066   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2067   if (b == NULL_TREE)
2068     return NULL_TREE;
2069   if (scope == NULL_TREE)
2070     scope = global_namespace;
2071   if (TREE_CODE (b) != CPLUS_BINDING)
2072     return (scope == global_namespace) ? b : NULL_TREE;
2073   name = find_binding (name,scope);
2074   if (name == NULL_TREE)
2075     return name;
2076   return BINDING_VALUE (name);
2077 }
2078
2079 /* Set the binding value for name in scope. If modifying the binding
2080    of global_namespace is attempted, try to optimize it. */
2081
2082 void
2083 set_namespace_binding (name, scope, val)
2084      tree name;
2085      tree scope;
2086      tree val;
2087 {
2088   tree b;
2089
2090   if (scope == NULL_TREE)
2091     scope = global_namespace;
2092
2093   if (scope == global_namespace)
2094     {
2095       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2096       if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2097         {
2098           IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2099           return;
2100         }
2101     }
2102   b = binding_for_name (name, scope);
2103   BINDING_VALUE (b) = val;
2104 }
2105
2106 /* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
2107    select a name that is unique to this compilation unit.  */
2108
2109 void
2110 push_namespace (name)
2111      tree name;
2112 {
2113   tree d = NULL_TREE;
2114   int need_new = 1;
2115   int implicit_use = 0;
2116   int global = 0;
2117   if (!global_namespace)
2118     {
2119       /* This must be ::. */
2120       my_friendly_assert (name == get_identifier ("::"), 377);
2121       global = 1;
2122     }
2123   else if (!name)
2124     {
2125       /* The name of anonymous namespace is unique for the translation
2126          unit.  */
2127       if (!anonymous_namespace_name)
2128         anonymous_namespace_name = get_file_function_name ('N');
2129       name = anonymous_namespace_name;
2130       d = IDENTIFIER_NAMESPACE_VALUE (name);
2131       if (d)
2132         /* Reopening anonymous namespace.  */
2133         need_new = 0;
2134       implicit_use = 1;
2135     }
2136   else if (current_namespace == global_namespace
2137            && name == DECL_NAME (std_node))
2138     {
2139       in_std++;
2140       return;
2141     }
2142   else
2143     {
2144       /* Check whether this is an extended namespace definition. */
2145       d = IDENTIFIER_NAMESPACE_VALUE (name);
2146       if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2147         {
2148           need_new = 0;
2149           if (DECL_NAMESPACE_ALIAS (d))
2150             {
2151               cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
2152                         d, DECL_NAMESPACE_ALIAS (d));
2153               d = DECL_NAMESPACE_ALIAS (d);
2154             }
2155         }
2156     }
2157
2158   if (need_new)
2159     {
2160       /* Make a new namespace, binding the name to it. */
2161       d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2162       /* The global namespace is not pushed, and the global binding
2163          level is set elsewhere.  */
2164       if (!global)
2165         {
2166           d = pushdecl (d);
2167           pushlevel (0);
2168           declare_namespace_level ();
2169           NAMESPACE_LEVEL (d) = current_binding_level;
2170         }
2171     }
2172   else
2173     resume_binding_level (NAMESPACE_LEVEL (d));
2174
2175   if (implicit_use)
2176     do_using_directive (d);
2177   /* Enter the name space. */
2178   current_namespace = d;
2179 }
2180
2181 /* Pop from the scope of the current namespace.  */
2182
2183 void
2184 pop_namespace ()
2185 {
2186   if (current_namespace == global_namespace)
2187     {
2188       my_friendly_assert (in_std>0, 980421);
2189       in_std--;
2190       return;
2191     }
2192   current_namespace = CP_DECL_CONTEXT (current_namespace);
2193   /* The binding level is not popped, as it might be re-opened later.  */
2194   suspend_binding_level ();
2195 }
2196
2197 /* Push into the scope of the namespace NS, even if it is deeply
2198    nested within another namespace.  */
2199
2200 void
2201 push_nested_namespace (ns)
2202      tree ns;
2203 {
2204   if (ns == global_namespace)
2205     push_to_top_level ();
2206   else
2207     {
2208       push_nested_namespace (CP_DECL_CONTEXT (ns));
2209       push_namespace (DECL_NAME (ns));
2210     }
2211 }
2212
2213 /* Pop back from the scope of the namespace NS, which was previously
2214    entered with push_nested_namespace.  */
2215
2216 void
2217 pop_nested_namespace (ns)
2218      tree ns;
2219 {
2220   while (ns != global_namespace)
2221     {
2222       pop_namespace ();
2223       ns = CP_DECL_CONTEXT (ns);
2224     }
2225
2226   pop_from_top_level ();
2227 }
2228
2229 \f
2230 /* Subroutines for reverting temporarily to top-level for instantiation
2231    of templates and such.  We actually need to clear out the class- and
2232    local-value slots of all identifiers, so that only the global values
2233    are at all visible.  Simply setting current_binding_level to the global
2234    scope isn't enough, because more binding levels may be pushed.  */
2235 struct saved_scope *scope_chain;
2236
2237 /* Mark ST for GC.  */
2238
2239 static void
2240 mark_stmt_tree (st)
2241      struct stmt_tree *st;
2242 {
2243   ggc_mark_tree (st->x_last_stmt);
2244   ggc_mark_tree (st->x_last_expr_type);
2245 }
2246
2247 /* Mark ARG (which is really a struct saved_scope **) for GC.  */
2248
2249 static void
2250 mark_saved_scope (arg)
2251      void *arg;
2252 {
2253   struct saved_scope *t = *(struct saved_scope **)arg;
2254   while (t)
2255     {
2256       mark_binding_level (&t->class_bindings);
2257       ggc_mark_tree (t->old_bindings);
2258       ggc_mark_tree (t->old_namespace);
2259       ggc_mark_tree (t->class_name);
2260       ggc_mark_tree (t->class_type);
2261       ggc_mark_tree (t->access_specifier);
2262       ggc_mark_tree (t->function_decl);
2263       if (t->lang_base)
2264         ggc_mark_tree_varray (t->lang_base);
2265       ggc_mark_tree (t->lang_name);
2266       ggc_mark_tree (t->x_function_parms);
2267       ggc_mark_tree (t->template_parms);
2268       ggc_mark_tree (t->x_previous_class_type);
2269       ggc_mark_tree (t->x_previous_class_values);
2270       ggc_mark_tree (t->x_saved_tree);
2271
2272       mark_stmt_tree (&t->x_stmt_tree);
2273       mark_binding_level (&t->bindings);
2274       t = t->prev;
2275     }
2276 }
2277
2278 static tree
2279 store_bindings (names, old_bindings)
2280      tree names, old_bindings;
2281 {
2282   tree t;
2283   for (t = names; t; t = TREE_CHAIN (t))
2284     {
2285       tree binding, t1, id;
2286
2287       if (TREE_CODE (t) == TREE_LIST)
2288         id = TREE_PURPOSE (t);
2289       else
2290         id = DECL_NAME (t);
2291
2292       if (!id
2293           /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2294              we have no IDENTIFIER_BINDING if we have left the class
2295              scope, but cached the class-level declarations.  */
2296           || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2297         continue;
2298
2299       for (t1 = old_bindings; t1; t1 = TREE_CHAIN (t1))
2300         if (TREE_VEC_ELT (t1, 0) == id)
2301           goto skip_it;
2302
2303       binding = make_tree_vec (4);
2304
2305       if (id)
2306         {
2307           my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2308           TREE_VEC_ELT (binding, 0) = id;
2309           TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2310           TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2311           TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2312           IDENTIFIER_BINDING (id) = NULL_TREE;
2313           IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2314         }
2315       TREE_CHAIN (binding) = old_bindings;
2316       old_bindings = binding;
2317     skip_it:
2318       ;
2319     }
2320   return old_bindings;
2321 }
2322
2323 void
2324 maybe_push_to_top_level (pseudo)
2325      int pseudo;
2326 {
2327   struct saved_scope *s;
2328   struct binding_level *b;
2329   tree old_bindings;
2330   int need_pop;
2331
2332   s = (struct saved_scope *) xcalloc (1, sizeof (struct saved_scope));
2333
2334   b = scope_chain ? current_binding_level : 0;
2335
2336   /* If we're in the middle of some function, save our state.  */
2337   if (current_function)
2338     {
2339       need_pop = 1;
2340       push_function_context_to (NULL_TREE);
2341     }
2342   else
2343     need_pop = 0;
2344
2345   old_bindings = NULL_TREE;
2346   if (scope_chain && previous_class_type)
2347     old_bindings = store_bindings (previous_class_values, old_bindings);
2348
2349   /* Have to include global_binding_level, because class-level decls
2350      aren't listed anywhere useful.  */
2351   for (; b; b = b->level_chain)
2352     {
2353       tree t;
2354
2355       /* Template IDs are inserted into the global level. If they were
2356          inserted into namespace level, finish_file wouldn't find them
2357          when doing pending instantiations. Therefore, don't stop at
2358          namespace level, but continue until :: .  */
2359       if (b == global_binding_level || (pseudo && b->pseudo_global))
2360         break;
2361
2362       old_bindings = store_bindings (b->names, old_bindings);
2363       /* We also need to check class_shadowed to save class-level type
2364          bindings, since pushclass doesn't fill in b->names.  */
2365       if (b->parm_flag == 2)
2366         old_bindings = store_bindings (b->class_shadowed, old_bindings);
2367
2368       /* Unwind type-value slots back to top level.  */
2369       for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2370         SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2371     }
2372   s->prev = scope_chain;
2373   s->old_bindings = old_bindings;
2374   s->bindings = b;
2375   s->need_pop_function_context = need_pop;
2376   s->function_decl = current_function_decl;
2377
2378   scope_chain = s;
2379   current_function_decl = NULL_TREE;
2380   VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2381   current_lang_stack = &VARRAY_TREE (current_lang_base, 0);
2382   current_lang_name = lang_name_cplusplus;
2383   strict_prototype = strict_prototypes_lang_cplusplus;
2384   current_namespace = global_namespace;
2385
2386   push_obstacks (&permanent_obstack, &permanent_obstack);
2387 }
2388
2389 void
2390 push_to_top_level ()
2391 {
2392   maybe_push_to_top_level (0);
2393 }
2394
2395 void
2396 pop_from_top_level ()
2397 {
2398   struct saved_scope *s = scope_chain;
2399   tree t;
2400
2401   /* Clear out class-level bindings cache.  */
2402   if (previous_class_type)
2403     invalidate_class_lookup_cache ();
2404
2405   pop_obstacks ();
2406
2407   VARRAY_FREE (current_lang_base);
2408
2409   scope_chain = s->prev;
2410   for (t = s->old_bindings; t; t = TREE_CHAIN (t))
2411     {
2412       tree id = TREE_VEC_ELT (t, 0);
2413       if (id)
2414         {
2415           SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2416           IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2417           IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2418         }
2419     }
2420
2421   if (current_lang_name == lang_name_cplusplus)
2422     strict_prototype = strict_prototypes_lang_cplusplus;
2423   else if (current_lang_name == lang_name_c)
2424     strict_prototype = strict_prototypes_lang_c;
2425
2426   /* If we were in the middle of compiling a function, restore our
2427      state.  */
2428   if (s->need_pop_function_context)
2429     pop_function_context_from (NULL_TREE);
2430   current_function_decl = s->function_decl;
2431
2432   free (s);
2433 }
2434 \f
2435 /* Push a definition of struct, union or enum tag "name".
2436    into binding_level "b".   "type" should be the type node,
2437    We assume that the tag "name" is not already defined.
2438
2439    Note that the definition may really be just a forward reference.
2440    In that case, the TYPE_SIZE will be a NULL_TREE.
2441
2442    C++ gratuitously puts all these tags in the name space.  */
2443
2444 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2445    record the shadowed value for this binding contour.  TYPE is
2446    the type that ID maps to.  */
2447
2448 static void
2449 set_identifier_type_value_with_scope (id, type, b)
2450      tree id;
2451      tree type;
2452      struct binding_level *b;
2453 {
2454   if (!b->namespace_p)
2455     {
2456       /* Shadow the marker, not the real thing, so that the marker
2457          gets restored later. */
2458       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2459       b->type_shadowed
2460         = tree_cons (id, old_type_value, b->type_shadowed);
2461     }
2462   else
2463     {
2464       tree binding = binding_for_name (id, current_namespace);
2465       BINDING_TYPE (binding) = type;
2466       /* Store marker instead of real type. */
2467       type = global_type_node;
2468     }
2469   SET_IDENTIFIER_TYPE_VALUE (id, type);
2470 }
2471
2472 /* As set_identifier_type_value_with_scope, but using current_binding_level.  */
2473
2474 void
2475 set_identifier_type_value (id, type)
2476      tree id;
2477      tree type;
2478 {
2479   set_identifier_type_value_with_scope (id, type, current_binding_level);
2480 }
2481
2482 /* Return the type associated with id. */
2483
2484 tree
2485 identifier_type_value (id)
2486      tree id;
2487 {
2488   /* There is no type with that name, anywhere. */
2489   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2490     return NULL_TREE;
2491   /* This is not the type marker, but the real thing. */
2492   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2493     return REAL_IDENTIFIER_TYPE_VALUE (id);
2494   /* Have to search for it. It must be on the global level, now.
2495      Ask lookup_name not to return non-types. */
2496   id = lookup_name_real (id, 2, 1, 0);
2497   if (id)
2498     return TREE_TYPE (id);
2499   return NULL_TREE;
2500 }
2501
2502 /* Pop off extraneous binding levels left over due to syntax errors.
2503
2504    We don't pop past namespaces, as they might be valid.  */
2505
2506 void
2507 pop_everything ()
2508 {
2509 #ifdef DEBUG_CP_BINDING_LEVELS
2510   fprintf (stderr, "XXX entering pop_everything ()\n");
2511 #endif
2512   while (!toplevel_bindings_p ())
2513     {
2514       if (current_binding_level->parm_flag == 2)
2515         pop_nested_class ();
2516       else
2517         poplevel (0, 0, 0);
2518     }
2519 #ifdef DEBUG_CP_BINDING_LEVELS
2520   fprintf (stderr, "XXX leaving pop_everything ()\n");
2521 #endif
2522 }
2523
2524 /* The type TYPE is being declared.  If it is a class template, or a
2525    specialization of a class template, do any processing required and
2526    perform error-checking.  If IS_FRIEND is non-zero, this TYPE is
2527    being declared a friend.  B is the binding level at which this TYPE
2528    should be bound.
2529
2530    Returns the TYPE_DECL for TYPE, which may have been altered by this
2531    processing.  */
2532
2533 static tree
2534 maybe_process_template_type_declaration (type, globalize, b)
2535      tree type;
2536      int globalize;
2537      struct binding_level* b;
2538 {
2539   tree decl = TYPE_NAME (type);
2540
2541   if (processing_template_parmlist)
2542     /* You can't declare a new template type in a template parameter
2543        list.  But, you can declare a non-template type:
2544
2545          template <class A*> struct S;
2546
2547        is a forward-declaration of `A'.  */
2548     ;
2549   else
2550     {
2551       maybe_check_template_type (type);
2552
2553       my_friendly_assert (IS_AGGR_TYPE (type)
2554                           || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2555
2556
2557       if (processing_template_decl)
2558         {
2559           /* This may change after the call to
2560              push_template_decl_real, but we want the original value.  */
2561           tree name = DECL_NAME (decl);
2562
2563           decl = push_template_decl_real (decl, globalize);
2564           /* If the current binding level is the binding level for the
2565              template parameters (see the comment in
2566              begin_template_parm_list) and the enclosing level is a class
2567              scope, and we're not looking at a friend, push the
2568              declaration of the member class into the class scope.  In the
2569              friend case, push_template_decl will already have put the
2570              friend into global scope, if appropriate.  */
2571           if (TREE_CODE (type) != ENUMERAL_TYPE
2572               && !globalize && b->pseudo_global
2573               && b->level_chain->parm_flag == 2)
2574             {
2575               finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2576               /* Put this tag on the list of tags for the class, since
2577                  that won't happen below because B is not the class
2578                  binding level, but is instead the pseudo-global level.  */
2579               b->level_chain->tags =
2580                 tree_cons (name, type, b->level_chain->tags);
2581               if (TYPE_SIZE (current_class_type) == NULL_TREE)
2582                 CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2583             }
2584         }
2585     }
2586
2587   return decl;
2588 }
2589
2590 /* In C++, you don't have to write `struct S' to refer to `S'; you
2591    can just use `S'.  We accomplish this by creating a TYPE_DECL as
2592    if the user had written `typedef struct S S'.  Create and return
2593    the TYPE_DECL for TYPE.  */
2594
2595 tree
2596 create_implicit_typedef (name, type)
2597      tree name;
2598      tree type;
2599 {
2600   tree decl;
2601
2602   decl = build_decl (TYPE_DECL, name, type);
2603   SET_DECL_ARTIFICIAL (decl);
2604   /* There are other implicit type declarations, like the one *within*
2605      a class that allows you to write `S::S'.  We must distinguish
2606      amongst these.  */
2607   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2608   TYPE_NAME (type) = decl;
2609
2610   return decl;
2611 }
2612
2613 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2614    Normally put it into the inner-most non-tag-transparent scope,
2615    but if GLOBALIZE is true, put it in the inner-most non-class scope.
2616    The latter is needed for implicit declarations.  */
2617
2618 void
2619 pushtag (name, type, globalize)
2620      tree name, type;
2621      int globalize;
2622 {
2623   register struct binding_level *b;
2624
2625   b = current_binding_level;
2626   while (b->tag_transparent
2627          || (globalize && b->parm_flag == 2))
2628     b = b->level_chain;
2629
2630   b->tags = tree_cons (name, type, b->tags);
2631
2632   if (name)
2633     {
2634       /* Do C++ gratuitous typedefing.  */
2635       if (IDENTIFIER_TYPE_VALUE (name) != type)
2636         {
2637           register tree d = NULL_TREE;
2638           int in_class = 0;
2639           tree context = TYPE_CONTEXT (type);
2640
2641           if (! context)
2642             {
2643               tree cs = current_scope ();
2644
2645               if (! globalize)
2646                 context = cs;
2647               else if (cs != NULL_TREE
2648                        && TREE_CODE_CLASS (TREE_CODE (cs)) == 't')
2649                 /* When declaring a friend class of a local class, we want
2650                    to inject the newly named class into the scope
2651                    containing the local class, not the namespace scope.  */
2652                 context = hack_decl_function_context (get_type_decl (cs));
2653             }
2654           if (!context)
2655             context = current_namespace;
2656
2657           if ((b->pseudo_global && b->level_chain->parm_flag == 2)
2658               || b->parm_flag == 2)
2659             in_class = 1;
2660
2661           if (current_lang_name == lang_name_java)
2662             TYPE_FOR_JAVA (type) = 1;
2663
2664           d = create_implicit_typedef (name, type);
2665           DECL_CONTEXT (d) = FROB_CONTEXT (context);
2666           if (! in_class)
2667             set_identifier_type_value_with_scope (name, type, b);
2668
2669           d = maybe_process_template_type_declaration (type,
2670                                                        globalize, b);
2671
2672           if (b->parm_flag == 2)
2673             {
2674               if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2675                 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2676                    class.  But if it's a member template class, we
2677                    want the TEMPLATE_DECL, not the TYPE_DECL, so this
2678                    is done later.  */
2679                 finish_member_declaration (d);
2680               else
2681                 pushdecl_class_level (d);
2682             }
2683           else
2684             d = pushdecl_with_scope (d, b);
2685
2686           if (ANON_AGGRNAME_P (name))
2687             DECL_IGNORED_P (d) = 1;
2688
2689           TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2690           DECL_ASSEMBLER_NAME (d) = DECL_NAME (d);
2691           if (!uses_template_parms (type))
2692             DECL_ASSEMBLER_NAME (d)
2693               = get_identifier (build_overload_name (type, 1, 1));
2694         }
2695       if (b->parm_flag == 2)
2696         {
2697           if (TYPE_SIZE (current_class_type) == NULL_TREE)
2698             CLASSTYPE_TAGS (current_class_type) = b->tags;
2699         }
2700     }
2701
2702   if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2703     /* Use the canonical TYPE_DECL for this node.  */
2704     TYPE_STUB_DECL (type) = TYPE_NAME (type);
2705   else
2706     {
2707       /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2708          will be the tagged type we just added to the current
2709          binding level.  This fake NULL-named TYPE_DECL node helps
2710          dwarfout.c to know when it needs to output a
2711          representation of a tagged type, and it also gives us a
2712          convenient place to record the "scope start" address for
2713          the tagged type.  */
2714
2715       tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2716       TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2717     }
2718 }
2719
2720 /* Counter used to create anonymous type names.  */
2721
2722 static int anon_cnt = 0;
2723
2724 /* Return an IDENTIFIER which can be used as a name for
2725    anonymous structs and unions.  */
2726
2727 tree
2728 make_anon_name ()
2729 {
2730   char buf[32];
2731
2732   sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2733   return get_identifier (buf);
2734 }
2735
2736 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2737    This keeps dbxout from getting confused.  */
2738
2739 void
2740 clear_anon_tags ()
2741 {
2742   register struct binding_level *b;
2743   register tree tags;
2744   static int last_cnt = 0;
2745
2746   /* Fast out if no new anon names were declared.  */
2747   if (last_cnt == anon_cnt)
2748     return;
2749
2750   b = current_binding_level;
2751   while (b->tag_transparent)
2752     b = b->level_chain;
2753   tags = b->tags;
2754   while (tags)
2755     {
2756       /* A NULL purpose means we have already processed all tags
2757          from here to the end of the list.  */
2758       if (TREE_PURPOSE (tags) == NULL_TREE)
2759         break;
2760       if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2761         TREE_PURPOSE (tags) = NULL_TREE;
2762       tags = TREE_CHAIN (tags);
2763     }
2764   last_cnt = anon_cnt;
2765 }
2766 \f
2767 /* Subroutine of duplicate_decls: return truthvalue of whether
2768    or not types of these decls match.
2769
2770    For C++, we must compare the parameter list so that `int' can match
2771    `int&' in a parameter position, but `int&' is not confused with
2772    `const int&'.  */
2773
2774 int
2775 decls_match (newdecl, olddecl)
2776      tree newdecl, olddecl;
2777 {
2778   int types_match;
2779
2780   if (newdecl == olddecl)
2781     return 1;
2782
2783   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
2784     /* If the two DECLs are not even the same kind of thing, we're not
2785        interested in their types.  */
2786     return 0;
2787
2788   if (TREE_CODE (newdecl) == FUNCTION_DECL)
2789     {
2790       tree f1 = TREE_TYPE (newdecl);
2791       tree f2 = TREE_TYPE (olddecl);
2792       tree p1 = TYPE_ARG_TYPES (f1);
2793       tree p2 = TYPE_ARG_TYPES (f2);
2794
2795       if (DECL_REAL_CONTEXT (newdecl) != DECL_REAL_CONTEXT (olddecl)
2796           && ! (DECL_LANGUAGE (newdecl) == lang_c
2797                 && DECL_LANGUAGE (olddecl) == lang_c))
2798         return 0;
2799
2800       /* When we parse a static member function definition,
2801          we put together a FUNCTION_DECL which thinks its type
2802          is METHOD_TYPE.  Change that to FUNCTION_TYPE, and
2803          proceed.  */
2804       if (TREE_CODE (f1) == METHOD_TYPE && DECL_STATIC_FUNCTION_P (olddecl))
2805         revert_static_member_fn (&newdecl, &f1, &p1);
2806       else if (TREE_CODE (f2) == METHOD_TYPE
2807                && DECL_STATIC_FUNCTION_P (newdecl))
2808         revert_static_member_fn (&olddecl, &f2, &p2);
2809
2810       /* Here we must take care of the case where new default
2811          parameters are specified.  Also, warn if an old
2812          declaration becomes ambiguous because default
2813          parameters may cause the two to be ambiguous.  */
2814       if (TREE_CODE (f1) != TREE_CODE (f2))
2815         {
2816           if (TREE_CODE (f1) == OFFSET_TYPE)
2817             cp_compiler_error ("`%D' redeclared as member function", newdecl);
2818           else
2819             cp_compiler_error ("`%D' redeclared as non-member function", newdecl);
2820           return 0;
2821         }
2822
2823       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
2824         {
2825           if (! strict_prototypes_lang_c && DECL_LANGUAGE (olddecl) == lang_c
2826               && p2 == NULL_TREE)
2827             {
2828               types_match = self_promoting_args_p (p1);
2829               if (p1 == void_list_node)
2830                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2831             }
2832           else if (!strict_prototypes_lang_c && DECL_LANGUAGE (olddecl)==lang_c
2833                    && DECL_LANGUAGE (newdecl) == lang_c && p1 == NULL_TREE)
2834             {
2835               types_match = self_promoting_args_p (p2);
2836               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2837             }
2838           else
2839             types_match = compparms (p1, p2);
2840         }
2841       else
2842         types_match = 0;
2843     }
2844   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2845     {
2846       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
2847                                 DECL_TEMPLATE_PARMS (olddecl)))
2848         return 0;
2849
2850       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2851         types_match = 1;
2852       else
2853         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
2854                                    DECL_TEMPLATE_RESULT (newdecl));
2855     }
2856   else
2857     {
2858       if (TREE_TYPE (newdecl) == error_mark_node)
2859         types_match = TREE_TYPE (olddecl) == error_mark_node;
2860       else if (TREE_TYPE (olddecl) == NULL_TREE)
2861         types_match = TREE_TYPE (newdecl) == NULL_TREE;
2862       else if (TREE_TYPE (newdecl) == NULL_TREE)
2863         types_match = 0;
2864       else
2865         types_match = comptypes (TREE_TYPE (newdecl),
2866                                  TREE_TYPE (olddecl),
2867                                  COMPARE_REDECLARATION);
2868     }
2869
2870   return types_match;
2871 }
2872
2873 /* If NEWDECL is `static' and an `extern' was seen previously,
2874    warn about it.  OLDDECL is the previous declaration.
2875
2876    Note that this does not apply to the C++ case of declaring
2877    a variable `extern const' and then later `const'.
2878
2879    Don't complain about built-in functions, since they are beyond
2880    the user's control.  */
2881
2882 static void
2883 warn_extern_redeclared_static (newdecl, olddecl)
2884      tree newdecl, olddecl;
2885 {
2886   static const char *explicit_extern_static_warning
2887     = "`%D' was declared `extern' and later `static'";
2888   static const char *implicit_extern_static_warning
2889     = "`%D' was declared implicitly `extern' and later `static'";
2890
2891   tree name;
2892
2893   if (TREE_CODE (newdecl) == TYPE_DECL
2894       || TREE_CODE (newdecl) == TEMPLATE_DECL)
2895     return;
2896
2897   /* Don't get confused by static member functions; that's a different
2898      use of `static'.  */
2899   if (TREE_CODE (newdecl) == FUNCTION_DECL
2900       && DECL_STATIC_FUNCTION_P (newdecl))
2901     return;
2902
2903   /* If the old declaration was `static', or the new one isn't, then
2904      then everything is OK.  */
2905   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
2906     return;
2907
2908   /* It's OK to declare a builtin function as `static'.  */
2909   if (TREE_CODE (olddecl) == FUNCTION_DECL
2910       && DECL_ARTIFICIAL (olddecl))
2911     return;
2912
2913   name = DECL_ASSEMBLER_NAME (newdecl);
2914   cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
2915               ? implicit_extern_static_warning
2916               : explicit_extern_static_warning, newdecl);
2917   cp_pedwarn_at ("previous declaration of `%D'", olddecl);
2918 }
2919
2920 /* Handle when a new declaration NEWDECL has the same name as an old
2921    one OLDDECL in the same binding contour.  Prints an error message
2922    if appropriate.
2923
2924    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
2925    Otherwise, return 0.  */
2926
2927 int
2928 duplicate_decls (newdecl, olddecl)
2929      tree newdecl, olddecl;
2930 {
2931   unsigned olddecl_uid = DECL_UID (olddecl);
2932   int olddecl_friend = 0, types_match = 0;
2933   int new_defines_function = 0;
2934
2935   if (newdecl == olddecl)
2936     return 1;
2937
2938   types_match = decls_match (newdecl, olddecl);
2939
2940   /* If either the type of the new decl or the type of the old decl is an
2941      error_mark_node, then that implies that we have already issued an
2942      error (earlier) for some bogus type specification, and in that case,
2943      it is rather pointless to harass the user with yet more error message
2944      about the same declaration, so just pretend the types match here.  */
2945   if (TREE_TYPE (newdecl) == error_mark_node
2946       || TREE_TYPE (olddecl) == error_mark_node)
2947     types_match = 1;
2948
2949   /* Check for redeclaration and other discrepancies. */
2950   if (TREE_CODE (olddecl) == FUNCTION_DECL
2951       && DECL_ARTIFICIAL (olddecl))
2952     {
2953       if (TREE_CODE (newdecl) != FUNCTION_DECL)
2954         {
2955           /* If you declare a built-in or predefined function name as static,
2956              the old definition is overridden, but optionally warn this was a
2957              bad choice of name.  */
2958           if (! TREE_PUBLIC (newdecl))
2959             {
2960               if (warn_shadow)
2961                 cp_warning ("shadowing %s function `%#D'",
2962                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
2963                             olddecl);
2964               /* Discard the old built-in function.  */
2965               return 0;
2966             }
2967           /* If the built-in is not ansi, then programs can override
2968              it even globally without an error.  */
2969           else if (! DECL_BUILT_IN (olddecl))
2970             cp_warning ("library function `%#D' redeclared as non-function `%#D'",
2971                         olddecl, newdecl);
2972           else
2973             {
2974               cp_error ("declaration of `%#D'", newdecl);
2975               cp_error ("conflicts with built-in declaration `%#D'",
2976                         olddecl);
2977             }
2978           return 0;
2979         }
2980       else if (!types_match)
2981         {
2982           if ((DECL_LANGUAGE (newdecl) == lang_c
2983                && DECL_LANGUAGE (olddecl) == lang_c)
2984               || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
2985                             TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
2986             {
2987               /* A near match; override the builtin.  */
2988
2989               if (TREE_PUBLIC (newdecl))
2990                 {
2991                   cp_warning ("new declaration `%#D'", newdecl);
2992                   cp_warning ("ambiguates built-in declaration `%#D'",
2993                               olddecl);
2994                 }
2995               else if (warn_shadow)
2996                 cp_warning ("shadowing %s function `%#D'",
2997                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
2998                             olddecl);
2999             }
3000           else
3001             /* Discard the old built-in function.  */
3002             return 0;
3003         }
3004
3005       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3006         {
3007           /* If a builtin function is redeclared as `static', merge
3008              the declarations, but make the original one static.  */
3009           DECL_THIS_STATIC (olddecl) = 1;
3010           TREE_PUBLIC (olddecl) = 0;
3011
3012           /* Make the olddeclaration consistent with the new one so that
3013              all remnants of the builtin-ness of this function will be
3014              banished.  */
3015           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3016           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3017           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3018           SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (newdecl),
3019                                        newdecl);
3020         }
3021     }
3022   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3023     {
3024       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3025            && TREE_CODE (newdecl) != TYPE_DECL
3026            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3027                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3028           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3029               && TREE_CODE (olddecl) != TYPE_DECL
3030               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3031                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3032                         == TYPE_DECL))))
3033         {
3034           /* We do nothing special here, because C++ does such nasty
3035              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
3036              get shadowed, and know that if we need to find a TYPE_DECL
3037              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3038              slot of the identifier.  */
3039           return 0;
3040         }
3041
3042       if ((TREE_CODE (newdecl) == FUNCTION_DECL
3043            && DECL_FUNCTION_TEMPLATE_P (olddecl))
3044           || (TREE_CODE (olddecl) == FUNCTION_DECL
3045               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3046         return 0;
3047
3048       cp_error ("`%#D' redeclared as different kind of symbol", newdecl);
3049       if (TREE_CODE (olddecl) == TREE_LIST)
3050         olddecl = TREE_VALUE (olddecl);
3051       cp_error_at ("previous declaration of `%#D'", olddecl);
3052
3053       /* New decl is completely inconsistent with the old one =>
3054          tell caller to replace the old one.  */
3055
3056       return 0;
3057     }
3058   else if (!types_match)
3059     {
3060       if (DECL_REAL_CONTEXT (newdecl) != DECL_REAL_CONTEXT (olddecl))
3061         /* These are certainly not duplicate declarations; they're
3062            from different scopes.  */
3063         return 0;
3064
3065       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3066         {
3067           /* The name of a class template may not be declared to refer to
3068              any other template, class, function, object, namespace, value,
3069              or type in the same scope.  */
3070           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3071               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3072             {
3073               cp_error ("declaration of template `%#D'", newdecl);
3074               cp_error_at ("conflicts with previous declaration `%#D'",
3075                            olddecl);
3076             }
3077           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3078                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3079                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3080                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3081                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3082                                            DECL_TEMPLATE_PARMS (olddecl)))
3083             {
3084               cp_error ("new declaration `%#D'", newdecl);
3085               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3086             }
3087           return 0;
3088         }
3089       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3090         {
3091           if (DECL_LANGUAGE (newdecl) == lang_c
3092               && DECL_LANGUAGE (olddecl) == lang_c)
3093             {
3094               cp_error ("declaration of C function `%#D' conflicts with",
3095                         newdecl);
3096               cp_error_at ("previous declaration `%#D' here", olddecl);
3097             }
3098           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3099                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3100             {
3101               cp_error ("new declaration `%#D'", newdecl);
3102               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3103             }
3104           else
3105             return 0;
3106         }
3107
3108       /* Already complained about this, so don't do so again.  */
3109       else if (current_class_type == NULL_TREE
3110           || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3111         {
3112           cp_error ("conflicting types for `%#D'", newdecl);
3113           cp_error_at ("previous declaration as `%#D'", olddecl);
3114         }
3115     }
3116   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3117             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3118                  && (!DECL_TEMPLATE_INFO (newdecl)
3119                      || (DECL_TI_TEMPLATE (newdecl)
3120                          != DECL_TI_TEMPLATE (olddecl))))
3121                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3122                     && (!DECL_TEMPLATE_INFO (olddecl)
3123                         || (DECL_TI_TEMPLATE (olddecl)
3124                             != DECL_TI_TEMPLATE (newdecl))))))
3125     /* It's OK to have a template specialization and a non-template
3126        with the same type, or to have specializations of two
3127        different templates with the same type.  Note that if one is a
3128        specialization, and the other is an instantiation of the same
3129        template, that we do not exit at this point.  That situation
3130        can occur if we instantiate a template class, and then
3131        specialize one of its methods.  This situation is legal, but
3132        the declarations must be merged in the usual way.  */
3133     return 0;
3134   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3135            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3136                 && !DECL_USE_TEMPLATE (newdecl))
3137                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3138                    && !DECL_USE_TEMPLATE (olddecl))))
3139     /* One of the declarations is a template instantiation, and the
3140        other is not a template at all.  That's OK.  */
3141     return 0;
3142   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3143            && DECL_NAMESPACE_ALIAS (newdecl)
3144            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3145     /* Redeclaration of namespace alias, ignore it. */
3146     return 1;
3147   else
3148     {
3149       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3150       if (errmsg)
3151         {
3152           cp_error (errmsg, newdecl);
3153           if (DECL_NAME (olddecl) != NULL_TREE)
3154             cp_error_at ((DECL_INITIAL (olddecl)
3155                           && namespace_bindings_p ())
3156                          ? "`%#D' previously defined here"
3157                          : "`%#D' previously declared here", olddecl);
3158         }
3159       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3160                && DECL_INITIAL (olddecl) != NULL_TREE
3161                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3162                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3163         {
3164           /* Prototype decl follows defn w/o prototype.  */
3165           cp_warning_at ("prototype for `%#D'", newdecl);
3166           cp_warning_at ("follows non-prototype definition here", olddecl);
3167         }
3168       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3169                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3170         {
3171           /* extern "C" int foo ();
3172              int foo () { bar (); }
3173              is OK.  */
3174           if (current_lang_stack
3175               == &VARRAY_TREE (current_lang_base, 0))
3176             DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3177           else
3178             {
3179               cp_error_at ("previous declaration of `%#D' with %L linkage",
3180                            olddecl, DECL_LANGUAGE (olddecl));
3181               cp_error ("conflicts with new declaration with %L linkage",
3182                         DECL_LANGUAGE (newdecl));
3183             }
3184         }
3185
3186       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3187         ;
3188       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3189         {
3190           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3191           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3192           int i = 1;
3193
3194           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3195             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3196
3197           for (; t1 && t1 != void_list_node;
3198                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3199             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3200               {
3201                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3202                                            TREE_PURPOSE (t2)))
3203                   {
3204                     if (pedantic)
3205                       {
3206                         cp_pedwarn ("default argument given for parameter %d of `%#D'",
3207                                     i, newdecl);
3208                         cp_pedwarn_at ("after previous specification in `%#D'",
3209                                        olddecl);
3210                       }
3211                   }
3212                 else
3213                   {
3214                     cp_error ("default argument given for parameter %d of `%#D'",
3215                               i, newdecl);
3216                     cp_error_at ("after previous specification in `%#D'",
3217                                  olddecl);
3218                   }
3219               }
3220
3221           if (DECL_THIS_INLINE (newdecl) && ! DECL_THIS_INLINE (olddecl)
3222               && TREE_ADDRESSABLE (olddecl) && warn_inline)
3223             {
3224               cp_warning ("`%#D' was used before it was declared inline",
3225                           newdecl);
3226               cp_warning_at ("previous non-inline declaration here",
3227                              olddecl);
3228             }
3229         }
3230     }
3231
3232   /* If new decl is `static' and an `extern' was seen previously,
3233      warn about it.  */
3234   warn_extern_redeclared_static (newdecl, olddecl);
3235
3236   /* We have committed to returning 1 at this point.  */
3237   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3238     {
3239       /* Now that functions must hold information normally held
3240          by field decls, there is extra work to do so that
3241          declaration information does not get destroyed during
3242          definition.  */
3243       if (DECL_VINDEX (olddecl))
3244         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3245       if (DECL_CONTEXT (olddecl))
3246         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3247       if (DECL_CLASS_CONTEXT (olddecl))
3248         DECL_CLASS_CONTEXT (newdecl) = DECL_CLASS_CONTEXT (olddecl);
3249       if (DECL_PENDING_INLINE_INFO (newdecl) == (struct pending_inline *)0)
3250         DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3251       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3252       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3253       DECL_ABSTRACT_VIRTUAL_P (newdecl) |= DECL_ABSTRACT_VIRTUAL_P (olddecl);
3254       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3255       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3256       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3257       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3258
3259       /* Optionally warn about more than one declaration for the same
3260          name, but don't warn about a function declaration followed by a
3261          definition.  */
3262       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3263           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3264           /* Don't warn about extern decl followed by definition. */
3265           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3266           /* Don't warn about friends, let add_friend take care of it. */
3267           && ! DECL_FRIEND_P (newdecl))
3268         {
3269           cp_warning ("redundant redeclaration of `%D' in same scope", newdecl);
3270           cp_warning_at ("previous declaration of `%D'", olddecl);
3271         }
3272     }
3273
3274   /* Deal with C++: must preserve virtual function table size.  */
3275   if (TREE_CODE (olddecl) == TYPE_DECL)
3276     {
3277       register tree newtype = TREE_TYPE (newdecl);
3278       register tree oldtype = TREE_TYPE (olddecl);
3279
3280       if (newtype != error_mark_node && oldtype != error_mark_node
3281           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3282         {
3283           CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
3284           CLASSTYPE_FRIEND_CLASSES (newtype)
3285             = CLASSTYPE_FRIEND_CLASSES (oldtype);
3286         }
3287     }
3288
3289   /* Copy all the DECL_... slots specified in the new decl
3290      except for any that we copy here from the old type.  */
3291   DECL_MACHINE_ATTRIBUTES (newdecl)
3292     = merge_machine_decl_attributes (olddecl, newdecl);
3293
3294   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3295     {
3296       if (! duplicate_decls (DECL_TEMPLATE_RESULT (newdecl),
3297                              DECL_TEMPLATE_RESULT (olddecl)))
3298         cp_error ("invalid redeclaration of %D", newdecl);
3299       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3300       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3301         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3302                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3303
3304       return 1;
3305     }
3306
3307   if (types_match)
3308     {
3309       /* Automatically handles default parameters.  */
3310       tree oldtype = TREE_TYPE (olddecl);
3311       tree newtype;
3312
3313       /* Make sure we put the new type in the same obstack as the old one.  */
3314       if (oldtype)
3315         push_obstacks (TYPE_OBSTACK (oldtype), TYPE_OBSTACK (oldtype));
3316       else
3317         push_permanent_obstack ();
3318
3319       /* Merge the data types specified in the two decls.  */
3320       newtype = common_type (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3321
3322       if (TREE_CODE (newdecl) == VAR_DECL)
3323         DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3324       /* Do this after calling `common_type' so that default
3325          parameters don't confuse us.  */
3326       else if (TREE_CODE (newdecl) == FUNCTION_DECL
3327           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3328               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3329         {
3330           TREE_TYPE (newdecl) = build_exception_variant (newtype,
3331                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3332           TREE_TYPE (olddecl) = build_exception_variant (newtype,
3333                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
3334
3335           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3336               && DECL_SOURCE_LINE (olddecl) != 0
3337               && flag_exceptions
3338               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3339                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3340             {
3341               cp_error ("declaration of `%F' throws different exceptions",
3342                         newdecl);
3343               cp_error_at ("to previous declaration `%F'", olddecl);
3344             }
3345         }
3346       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3347
3348       /* Lay the type out, unless already done.  */
3349       if (! same_type_p (newtype, oldtype)
3350           && TREE_TYPE (newdecl) != error_mark_node
3351           && !(processing_template_decl && uses_template_parms (newdecl)))
3352         layout_type (TREE_TYPE (newdecl));
3353
3354       if ((TREE_CODE (newdecl) == VAR_DECL
3355            || TREE_CODE (newdecl) == PARM_DECL
3356            || TREE_CODE (newdecl) == RESULT_DECL
3357            || TREE_CODE (newdecl) == FIELD_DECL
3358            || TREE_CODE (newdecl) == TYPE_DECL)
3359           && !(processing_template_decl && uses_template_parms (newdecl)))
3360         layout_decl (newdecl, 0);
3361
3362       /* Merge the type qualifiers.  */
3363       if (TREE_READONLY (newdecl))
3364         TREE_READONLY (olddecl) = 1;
3365       if (TREE_THIS_VOLATILE (newdecl))
3366         TREE_THIS_VOLATILE (olddecl) = 1;
3367
3368       /* Merge the initialization information.  */
3369       if (DECL_INITIAL (newdecl) == NULL_TREE
3370           && DECL_INITIAL (olddecl) != NULL_TREE)
3371         {
3372           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3373           DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
3374           DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
3375           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3376               && DECL_LANG_SPECIFIC (newdecl)
3377               && DECL_LANG_SPECIFIC (olddecl))
3378             DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3379         }
3380
3381       /* Merge the section attribute.
3382          We want to issue an error if the sections conflict but that must be
3383          done later in decl_attributes since we are called before attributes
3384          are assigned.  */
3385       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3386         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3387
3388       /* Keep the old rtl since we can safely use it.  */
3389       DECL_RTL (newdecl) = DECL_RTL (olddecl);
3390
3391       pop_obstacks ();
3392     }
3393   /* If cannot merge, then use the new type and qualifiers,
3394      and don't preserve the old rtl.  */
3395   else
3396     {
3397       /* Clean out any memory we had of the old declaration.  */
3398       tree oldstatic = value_member (olddecl, static_aggregates);
3399       if (oldstatic)
3400         TREE_VALUE (oldstatic) = error_mark_node;
3401
3402       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3403       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3404       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3405       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3406     }
3407
3408   /* Merge the storage class information.  */
3409   DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
3410   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3411   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3412   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3413   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3414   if (! DECL_EXTERNAL (olddecl))
3415     DECL_EXTERNAL (newdecl) = 0;
3416
3417   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3418     {
3419       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3420       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3421       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3422       DECL_TEMPLATE_INSTANTIATED (newdecl)
3423         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3424       /* Don't really know how much of the language-specific
3425          values we should copy from old to new.  */
3426       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3427       DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
3428       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3429       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3430       olddecl_friend = DECL_FRIEND_P (olddecl);
3431
3432       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
3433       if (TREE_CODE (newdecl) == FUNCTION_DECL
3434           || DECL_FUNCTION_TEMPLATE_P (newdecl))
3435         DECL_BEFRIENDING_CLASSES (newdecl)
3436           = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3437                      DECL_BEFRIENDING_CLASSES (olddecl));
3438     }
3439
3440   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3441     {
3442       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3443           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3444         {
3445           /* If newdecl is not a specialization, then it is not a
3446              template-related function at all.  And that means that we
3447              shoud have exited above, returning 0.  */
3448           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3449                               0);
3450
3451           if (TREE_USED (olddecl))
3452             /* From [temp.expl.spec]:
3453
3454                If a template, a member template or the member of a class
3455                template is explicitly specialized then that
3456                specialization shall be declared before the first use of
3457                that specialization that would cause an implicit
3458                instantiation to take place, in every translation unit in
3459                which such a use occurs.  */
3460             cp_error ("explicit specialization of %D after first use",
3461                       olddecl);
3462
3463           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3464         }
3465       DECL_THIS_INLINE (newdecl) |= DECL_THIS_INLINE (olddecl);
3466
3467       /* If either decl says `inline', this fn is inline, unless its
3468          definition was passed already.  */
3469       if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3470         DECL_INLINE (olddecl) = 1;
3471       DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3472
3473       if (! types_match)
3474         {
3475           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3476           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3477           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3478         }
3479       if (! types_match || new_defines_function)
3480         {
3481           /* These need to be copied so that the names are available.
3482              Note that if the types do match, we'll preserve inline
3483              info and other bits, but if not, we won't.  */
3484           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3485           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3486         }
3487       if (new_defines_function)
3488         /* If defining a function declared with other language
3489            linkage, use the previously declared language linkage.  */
3490         DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3491       else if (types_match)
3492         {
3493           /* If redeclaring a builtin function, and not a definition,
3494              it stays built in.  */
3495           if (DECL_BUILT_IN (olddecl))
3496             {
3497               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3498               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3499               /* If we're keeping the built-in definition, keep the rtl,
3500                  regardless of declaration matches.  */
3501               DECL_RTL (newdecl) = DECL_RTL (olddecl);
3502             }
3503           else
3504             DECL_FRAME_SIZE (newdecl) = DECL_FRAME_SIZE (olddecl);
3505
3506           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3507           if ((DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl)))
3508             /* Previously saved insns go together with
3509                the function's previous definition.  */
3510             DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3511           /* Don't clear out the arguments if we're redefining a function.  */
3512           if (DECL_ARGUMENTS (olddecl))
3513             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3514         }
3515       if (DECL_LANG_SPECIFIC (olddecl))
3516         DECL_MAIN_VARIANT (newdecl) = DECL_MAIN_VARIANT (olddecl);
3517     }
3518
3519   if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3520     {
3521       NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3522     }
3523
3524   /* Now preserve various other info from the definition.  */
3525   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3526   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3527   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3528   DECL_ASSEMBLER_NAME (newdecl) = DECL_ASSEMBLER_NAME (olddecl);
3529
3530   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3531     {
3532       int function_size;
3533
3534       function_size = sizeof (struct tree_decl);
3535
3536       bcopy ((char *) newdecl + sizeof (struct tree_common),
3537              (char *) olddecl + sizeof (struct tree_common),
3538              function_size - sizeof (struct tree_common));
3539
3540       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3541         {
3542           /* If newdecl is a template instantiation, it is possible that
3543              the following sequence of events has occurred:
3544
3545              o A friend function was declared in a class template.  The
3546              class template was instantiated.
3547
3548              o The instantiation of the friend declaration was
3549              recorded on the instantiation list, and is newdecl.
3550
3551              o Later, however, instantiate_class_template called pushdecl
3552              on the newdecl to perform name injection.  But, pushdecl in
3553              turn called duplicate_decls when it discovered that another
3554              declaration of a global function with the same name already
3555              existed.
3556
3557              o Here, in duplicate_decls, we decided to clobber newdecl.
3558
3559              If we're going to do that, we'd better make sure that
3560              olddecl, and not newdecl, is on the list of
3561              instantiations so that if we try to do the instantiation
3562              again we won't get the clobbered declaration.  */
3563
3564           tree tmpl = DECL_TI_TEMPLATE (newdecl);
3565           tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3566
3567           for (; decls; decls = TREE_CHAIN (decls))
3568             if (TREE_VALUE (decls) == newdecl)
3569               TREE_VALUE (decls) = olddecl;
3570         }
3571     }
3572   else
3573     {
3574       bcopy ((char *) newdecl + sizeof (struct tree_common),
3575              (char *) olddecl + sizeof (struct tree_common),
3576              sizeof (struct tree_decl) - sizeof (struct tree_common)
3577              + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
3578     }
3579
3580   DECL_UID (olddecl) = olddecl_uid;
3581   if (olddecl_friend)
3582     DECL_FRIEND_P (olddecl) = 1;
3583
3584   /* NEWDECL contains the merged attribute lists.
3585      Update OLDDECL to be the same.  */
3586   DECL_MACHINE_ATTRIBUTES (olddecl) = DECL_MACHINE_ATTRIBUTES (newdecl);
3587
3588   return 1;
3589 }
3590
3591 /* Record a decl-node X as belonging to the current lexical scope.
3592    Check for errors (such as an incompatible declaration for the same
3593    name already seen in the same scope).
3594
3595    Returns either X or an old decl for the same name.
3596    If an old decl is returned, it may have been smashed
3597    to agree with what X says.  */
3598
3599 tree
3600 pushdecl (x)
3601      tree x;
3602 {
3603   register tree t;
3604   register tree name;
3605   int need_new_binding;
3606
3607   /* We shouldn't be calling pushdecl when we're generating RTL for a
3608      function that we already did semantic analysis on previously.  */
3609   my_friendly_assert (!current_function || doing_semantic_analysis_p (),
3610                       19990913);
3611
3612   name = DECL_ASSEMBLER_NAME (x);
3613   need_new_binding = 1;
3614
3615   if (DECL_TEMPLATE_PARM_P (x))
3616     /* Template parameters have no context; they are not X::T even
3617        when declared within a class or namespace.  */
3618     ;
3619   else
3620     {
3621       if (current_function_decl && x != current_function_decl
3622           /* A local declaration for a function doesn't constitute
3623              nesting.  */
3624           && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3625           /* A local declaration for an `extern' variable is in the
3626              scoped of the current namespace, not the current
3627              function.  */
3628           && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3629           /* Don't change DECL_CONTEXT of virtual methods.  */
3630           && (TREE_CODE (x) != FUNCTION_DECL || !DECL_VIRTUAL_P (x))
3631           && !DECL_CONTEXT (x))
3632         DECL_CONTEXT (x) = current_function_decl;
3633       if (!DECL_CONTEXT (x))
3634         DECL_CONTEXT (x) = FROB_CONTEXT (current_namespace);
3635     }
3636
3637   /* Type are looked up using the DECL_NAME, as that is what the rest of the
3638      compiler wants to use.  */
3639   if (TREE_CODE (x) == TYPE_DECL || TREE_CODE (x) == VAR_DECL
3640       || TREE_CODE (x) == NAMESPACE_DECL)
3641     name = DECL_NAME (x);
3642
3643   if (name)
3644     {
3645 #if 0
3646       /* Not needed...see below.  */
3647       char *file;
3648       int line;
3649 #endif
3650       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3651         name = TREE_OPERAND (name, 0);
3652
3653       /* Namespace-scoped variables are not found in the current level. */
3654       if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x))
3655         t = namespace_binding (name, DECL_CONTEXT (x));
3656       else
3657         t = lookup_name_current_level (name);
3658       if (t == error_mark_node)
3659         {
3660           /* error_mark_node is 0 for a while during initialization!  */
3661           t = NULL_TREE;
3662           cp_error_at ("`%#D' used prior to declaration", x);
3663         }
3664
3665       else if (t != NULL_TREE)
3666         {
3667 #if 0
3668           /* This is turned off until I have time to do it right (bpk).  */
3669           /* With the code below that uses it...  */
3670           file = DECL_SOURCE_FILE (t);
3671           line = DECL_SOURCE_LINE (t);
3672 #endif
3673           if (TREE_CODE (t) == PARM_DECL)
3674             {
3675               if (DECL_CONTEXT (t) == NULL_TREE)
3676                 fatal ("parse errors have confused me too much");
3677
3678               /* Check for duplicate params.  */
3679               if (duplicate_decls (x, t))
3680                 return t;
3681             }
3682           else if (((TREE_CODE (x) == FUNCTION_DECL && DECL_LANGUAGE (x) == lang_c)
3683                     || DECL_FUNCTION_TEMPLATE_P (x))
3684                    && is_overloaded_fn (t))
3685             /* Don't do anything just yet. */;
3686           else if (t == wchar_decl_node)
3687             {
3688               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3689                 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x));
3690
3691               /* Throw away the redeclaration.  */
3692               return t;
3693             }
3694           else if (TREE_CODE (t) != TREE_CODE (x))
3695             {
3696               if (duplicate_decls (x, t))
3697                 return t;
3698             }
3699           else if (duplicate_decls (x, t))
3700             {
3701 #if 0
3702               /* This is turned off until I have time to do it right (bpk).  */
3703
3704               /* Also warn if they did a prototype with `static' on it, but
3705                  then later left the `static' off.  */
3706               if (! TREE_PUBLIC (name) && TREE_PUBLIC (x))
3707                 {
3708                   if (DECL_LANG_SPECIFIC (t) && DECL_FRIEND_P (t))
3709                     return t;
3710
3711                   if (extra_warnings)
3712                     {
3713                       cp_warning ("`static' missing from declaration of `%D'",
3714                                   t);
3715                       warning_with_file_and_line (file, line,
3716                                                   "previous declaration of `%s'",
3717                                                   decl_as_string (t, 0));
3718                     }
3719
3720                   /* Now fix things so it'll do what they expect.  */
3721                   if (current_function_decl)
3722                     TREE_PUBLIC (current_function_decl) = 0;
3723                 }
3724               /* Due to interference in memory reclamation (X may be
3725                  obstack-deallocated at this point), we must guard against
3726                  one really special case.  [jason: This should be handled
3727                  by start_function]  */
3728               if (current_function_decl == x)
3729                 current_function_decl = t;
3730 #endif
3731               if (TREE_CODE (t) == TYPE_DECL)
3732                 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3733               else if (TREE_CODE (t) == FUNCTION_DECL)
3734                 check_default_args (t);
3735
3736               return t;
3737             }
3738           else if (DECL_MAIN_P (x))
3739             {
3740               /* A redeclaration of main, but not a duplicate of the
3741                  previous one.
3742
3743                  [basic.start.main]
3744
3745                  This function shall not be overloaded.  */
3746               cp_error_at ("invalid redeclaration of `%D'", t);
3747               cp_error ("as `%D'", x);
3748               /* We don't try to push this declaration since that
3749                  causes a crash.  */
3750               return x;
3751             }
3752         }
3753
3754       check_template_shadow (x);
3755
3756       /* If this is a function conjured up by the backend, massage it
3757          so it looks friendly.  */
3758       if (TREE_CODE (x) == FUNCTION_DECL
3759           && ! DECL_LANG_SPECIFIC (x))
3760         {
3761           retrofit_lang_decl (x);
3762           DECL_LANGUAGE (x) = lang_c;
3763         }
3764
3765       if (TREE_CODE (x) == FUNCTION_DECL && ! DECL_FUNCTION_MEMBER_P (x))
3766         {
3767           t = push_overloaded_decl (x, PUSH_LOCAL);
3768           if (t != x)
3769             return t;
3770           if (!namespace_bindings_p ())
3771             /* We do not need to create a binding for this name;
3772                push_overloaded_decl will have already done so if
3773                necessary.  */
3774             need_new_binding = 0;
3775         }
3776       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
3777         {
3778           t = push_overloaded_decl (x, PUSH_GLOBAL);
3779           if (t == x)
3780             add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
3781           return t;
3782         }
3783
3784       /* If declaring a type as a typedef, copy the type (unless we're
3785          at line 0), and install this TYPE_DECL as the new type's typedef
3786          name.  See the extensive comment in ../c-decl.c (pushdecl). */
3787       if (TREE_CODE (x) == TYPE_DECL)
3788         {
3789           tree type = TREE_TYPE (x);
3790           if (DECL_SOURCE_LINE (x) == 0)
3791             {
3792               if (TYPE_NAME (type) == 0)
3793                 TYPE_NAME (type) = x;
3794             }
3795           else if (type != error_mark_node && TYPE_NAME (type) != x
3796                    /* We don't want to copy the type when all we're
3797                       doing is making a TYPE_DECL for the purposes of
3798                       inlining.  */
3799                    && (!TYPE_NAME (type)
3800                        || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
3801             {
3802               push_obstacks (TYPE_OBSTACK (type), TYPE_OBSTACK (type));
3803
3804               DECL_ORIGINAL_TYPE (x) = type;
3805               type = build_type_copy (type);
3806               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
3807               TYPE_NAME (type) = x;
3808               TREE_TYPE (x) = type;
3809
3810               pop_obstacks ();
3811             }
3812
3813           if (type != error_mark_node
3814               && TYPE_NAME (type)
3815               && TYPE_IDENTIFIER (type))
3816             set_identifier_type_value_with_scope (DECL_NAME (x), type,
3817                                                   current_binding_level);
3818
3819         }
3820
3821       /* Multiple external decls of the same identifier ought to match.
3822
3823          We get warnings about inline functions where they are defined.
3824          We get warnings about other functions from push_overloaded_decl.
3825
3826          Avoid duplicate warnings where they are used.  */
3827       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
3828         {
3829           tree decl;
3830
3831           if (IDENTIFIER_NAMESPACE_VALUE (name) != NULL_TREE
3832               && (DECL_EXTERNAL (IDENTIFIER_NAMESPACE_VALUE (name))
3833                   || TREE_PUBLIC (IDENTIFIER_NAMESPACE_VALUE (name))))
3834             decl = IDENTIFIER_NAMESPACE_VALUE (name);
3835           else
3836             decl = NULL_TREE;
3837
3838           if (decl
3839               /* If different sort of thing, we already gave an error.  */
3840               && TREE_CODE (decl) == TREE_CODE (x)
3841               && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
3842             {
3843               cp_pedwarn ("type mismatch with previous external decl", x);
3844               cp_pedwarn_at ("previous external decl of `%#D'", decl);
3845             }
3846         }
3847
3848       /* This name is new in its binding level.
3849          Install the new declaration and return it.  */
3850       if (namespace_bindings_p ())
3851         {
3852           /* Install a global value.  */
3853
3854           /* If the first global decl has external linkage,
3855              warn if we later see static one.  */
3856           if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
3857             TREE_PUBLIC (name) = 1;
3858
3859           if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
3860                 && t != NULL_TREE)
3861               /* For an ordinary function, we create a binding from
3862                  the mangled name (i.e., NAME) to the DECL.  But, for
3863                  an `extern "C"' function, the mangled name and the
3864                  ordinary name are the same so we need not do this.  */
3865               && !(TREE_CODE (x) == FUNCTION_DECL &&
3866                    DECL_LANGUAGE (x) == lang_c))
3867             {
3868               if (TREE_CODE (x) == FUNCTION_DECL)
3869                 my_friendly_assert
3870                   ((IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE)
3871                   || (IDENTIFIER_GLOBAL_VALUE (name) == x), 378);
3872               SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
3873             }
3874
3875           /* Don't forget if the function was used via an implicit decl.  */
3876           if (IDENTIFIER_IMPLICIT_DECL (name)
3877               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
3878             TREE_USED (x) = 1;
3879
3880           /* Don't forget if its address was taken in that way.  */
3881           if (IDENTIFIER_IMPLICIT_DECL (name)
3882               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
3883             TREE_ADDRESSABLE (x) = 1;
3884
3885           /* Warn about mismatches against previous implicit decl.  */
3886           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
3887               /* If this real decl matches the implicit, don't complain.  */
3888               && ! (TREE_CODE (x) == FUNCTION_DECL
3889                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
3890             cp_warning
3891               ("`%D' was previously implicitly declared to return `int'", x);
3892
3893           /* If new decl is `static' and an `extern' was seen previously,
3894              warn about it.  */
3895           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
3896             warn_extern_redeclared_static (x, t);
3897         }
3898       else
3899         {
3900           /* Here to install a non-global value.  */
3901           tree oldlocal = IDENTIFIER_VALUE (name);
3902           tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
3903
3904           if (need_new_binding)
3905             {
3906               push_local_binding (name, x, 0);
3907               /* Because push_local_binding will hook X on to the
3908                  current_binding_level's name list, we don't want to
3909                  do that again below.  */
3910               need_new_binding = 0;
3911             }
3912
3913           /* If this is a TYPE_DECL, push it into the type value slot.  */
3914           if (TREE_CODE (x) == TYPE_DECL)
3915             set_identifier_type_value_with_scope (name, TREE_TYPE (x),
3916                                                   current_binding_level);
3917
3918           /* Clear out any TYPE_DECL shadowed by a namespace so that
3919              we won't think this is a type.  The C struct hack doesn't
3920              go through namespaces.  */
3921           if (TREE_CODE (x) == NAMESPACE_DECL)
3922             set_identifier_type_value_with_scope (name, NULL_TREE,
3923                                                   current_binding_level);
3924
3925           /* If this is an extern function declaration, see if we
3926              have a global definition or declaration for the function.  */
3927           if (oldlocal == NULL_TREE
3928               && DECL_EXTERNAL (x)
3929               && oldglobal != NULL_TREE
3930               && TREE_CODE (x) == FUNCTION_DECL
3931               && TREE_CODE (oldglobal) == FUNCTION_DECL)
3932             {
3933               /* We have one.  Their types must agree.  */
3934               if (decls_match (x, oldglobal))
3935                 /* OK */;
3936               else
3937                 {
3938                   cp_warning ("extern declaration of `%#D' doesn't match", x);
3939                   cp_warning_at ("global declaration `%#D'", oldglobal);
3940                 }
3941             }
3942           /* If we have a local external declaration,
3943              and no file-scope declaration has yet been seen,
3944              then if we later have a file-scope decl it must not be static.  */
3945           if (oldlocal == NULL_TREE
3946               && oldglobal == NULL_TREE
3947               && DECL_EXTERNAL (x)
3948               && TREE_PUBLIC (x))
3949             TREE_PUBLIC (name) = 1;
3950
3951           if (DECL_FROM_INLINE (x))
3952             /* Inline decls shadow nothing.  */;
3953
3954           /* Warn if shadowing an argument at the top level of the body.  */
3955           else if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
3956                    && TREE_CODE (oldlocal) == PARM_DECL
3957                    /* Don't complain if it's from an enclosing function.  */
3958                    && DECL_CONTEXT (oldlocal) == current_function_decl
3959                    && TREE_CODE (x) != PARM_DECL)
3960             {
3961               /* Go to where the parms should be and see if we
3962                  find them there.  */
3963               struct binding_level *b = current_binding_level->level_chain;
3964
3965               if (cleanup_label)
3966                 b = b->level_chain;
3967
3968               /* ARM $8.3 */
3969               if (b->parm_flag == 1)
3970                 cp_error ("declaration of `%#D' shadows a parameter", name);
3971             }
3972           else if (warn_shadow && oldlocal != NULL_TREE
3973                    && current_binding_level->is_for_scope
3974                    && !DECL_DEAD_FOR_LOCAL (oldlocal))
3975             {
3976               warning ("variable `%s' shadows local",
3977                        IDENTIFIER_POINTER (name));
3978               cp_warning_at ("  this is the shadowed declaration", oldlocal);
3979             }
3980           /* Maybe warn if shadowing something else.  */
3981           else if (warn_shadow && !DECL_EXTERNAL (x)
3982                    /* No shadow warnings for internally generated vars.  */
3983                    && ! DECL_ARTIFICIAL (x)
3984                    /* No shadow warnings for vars made for inlining.  */
3985                    && ! DECL_FROM_INLINE (x))
3986             {
3987               const char *warnstring = NULL;
3988
3989               if (oldlocal != NULL_TREE && TREE_CODE (oldlocal) == PARM_DECL)
3990                 warnstring = "declaration of `%s' shadows a parameter";
3991               else if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
3992                        && current_class_ptr
3993                        && !TREE_STATIC (name))
3994                 warnstring = "declaration of `%s' shadows a member of `this'";
3995               else if (oldlocal != NULL_TREE)
3996                 warnstring = "declaration of `%s' shadows previous local";
3997               else if (oldglobal != NULL_TREE)
3998                 /* XXX shadow warnings in outer-more namespaces */
3999                 warnstring = "declaration of `%s' shadows global declaration";
4000
4001               if (warnstring)
4002                 warning (warnstring, IDENTIFIER_POINTER (name));
4003             }
4004         }
4005
4006       if (TREE_CODE (x) == FUNCTION_DECL)
4007         check_default_args (x);
4008
4009       /* Keep count of variables in this level with incomplete type.  */
4010       if (TREE_CODE (x) == VAR_DECL
4011           && TREE_TYPE (x) != error_mark_node
4012           && ((TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
4013                && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
4014               /* RTTI TD entries are created while defining the type_info.  */
4015               || (TYPE_LANG_SPECIFIC (TREE_TYPE (x))
4016                   && TYPE_BEING_DEFINED (TREE_TYPE (x)))))
4017         current_binding_level->incomplete
4018           = tree_cons (NULL_TREE, x, current_binding_level->incomplete);
4019     }
4020
4021   if (need_new_binding)
4022     add_decl_to_level (x,
4023                        DECL_NAMESPACE_SCOPE_P (x)
4024                        ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4025                        : current_binding_level);
4026
4027   return x;
4028 }
4029
4030 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
4031    caller to set DECL_CONTEXT properly.  */
4032
4033 static tree
4034 pushdecl_with_scope (x, level)
4035      tree x;
4036      struct binding_level *level;
4037 {
4038   register struct binding_level *b;
4039   tree function_decl = current_function_decl;
4040
4041   current_function_decl = NULL_TREE;
4042   if (level->parm_flag == 2)
4043     {
4044       b = class_binding_level;
4045       class_binding_level = level;
4046       pushdecl_class_level (x);
4047       class_binding_level = b;
4048     }
4049   else
4050     {
4051       b = current_binding_level;
4052       current_binding_level = level;
4053       x = pushdecl (x);
4054       current_binding_level = b;
4055     }
4056   current_function_decl = function_decl;
4057   return x;
4058 }
4059
4060 /* Like pushdecl, only it places X in the current namespace,
4061    if appropriate.  */
4062
4063 tree
4064 pushdecl_namespace_level (x)
4065      tree x;
4066 {
4067   register struct binding_level *b = current_binding_level;
4068   register tree t;
4069
4070   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4071
4072   /* Now, the type_shadowed stack may screw us.  Munge it so it does
4073      what we want.  */
4074   if (TREE_CODE (x) == TYPE_DECL)
4075     {
4076       tree name = DECL_NAME (x);
4077       tree newval;
4078       tree *ptr = (tree *)0;
4079       for (; b != global_binding_level; b = b->level_chain)
4080         {
4081           tree shadowed = b->type_shadowed;
4082           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4083             if (TREE_PURPOSE (shadowed) == name)
4084               {
4085                 ptr = &TREE_VALUE (shadowed);
4086                 /* Can't break out of the loop here because sometimes
4087                    a binding level will have duplicate bindings for
4088                    PT names.  It's gross, but I haven't time to fix it.  */
4089               }
4090         }
4091       newval = TREE_TYPE (x);
4092       if (ptr == (tree *)0)
4093         {
4094           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
4095              up here if this is changed to an assertion.  --KR  */
4096           SET_IDENTIFIER_TYPE_VALUE (name, newval);
4097         }
4098       else
4099         {
4100           *ptr = newval;
4101         }
4102     }
4103   return t;
4104 }
4105
4106 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4107    if appropriate.  */
4108
4109 tree
4110 pushdecl_top_level (x)
4111      tree x;
4112 {
4113   push_to_top_level ();
4114   x = pushdecl_namespace_level (x);
4115   pop_from_top_level ();
4116   return x;
4117 }
4118
4119 /* Make the declaration of X appear in CLASS scope.  */
4120
4121 void
4122 pushdecl_class_level (x)
4123      tree x;
4124 {
4125   /* Don't use DECL_ASSEMBLER_NAME here!  Everything that looks in class
4126      scope looks for the pre-mangled name.  */
4127   register tree name;
4128
4129   if (TREE_CODE (x) == OVERLOAD)
4130     x = OVL_CURRENT (x);
4131   name = DECL_NAME (x);
4132
4133   if (name)
4134     {
4135       push_class_level_binding (name, x);
4136       if (TREE_CODE (x) == TYPE_DECL)
4137         set_identifier_type_value (name, TREE_TYPE (x));
4138     }
4139   else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4140     {
4141       tree f;
4142
4143       for (f = TYPE_FIELDS (TREE_TYPE (x));
4144            f;
4145            f = TREE_CHAIN (f))
4146         pushdecl_class_level (f);
4147     }
4148 }
4149
4150 /* Enter DECL into the symbol table, if that's appropriate.  Returns
4151    DECL, or a modified version thereof.  */
4152
4153 tree
4154 maybe_push_decl (decl)
4155      tree decl;
4156 {
4157   tree type = TREE_TYPE (decl);
4158
4159   /* Add this decl to the current binding level, but not if it comes
4160      from another scope, e.g. a static member variable.  TEM may equal
4161      DECL or it may be a previous decl of the same name.  */
4162   if ((TREE_CODE (decl) != PARM_DECL
4163        && DECL_CONTEXT (decl) != NULL_TREE
4164        /* Definitions of namespace members outside their namespace are
4165           possible. */
4166        && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4167       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4168       || TREE_CODE (type) == UNKNOWN_TYPE
4169       /* The declaration of a template specialization does not affect
4170          the functions available for overload resolution, so we do not
4171          call pushdecl.  */
4172       || (TREE_CODE (decl) == FUNCTION_DECL
4173           && DECL_TEMPLATE_SPECIALIZATION (decl)))
4174     return decl;
4175   else
4176     return pushdecl (decl);
4177 }
4178
4179 #if 0
4180 /* This function is used to push the mangled decls for nested types into
4181    the appropriate scope.  Previously pushdecl_top_level was used, but that
4182    is incorrect for members of local classes.  */
4183
4184 void
4185 pushdecl_nonclass_level (x)
4186      tree x;
4187 {
4188   struct binding_level *b = current_binding_level;
4189
4190   my_friendly_assert (b->parm_flag != 2, 180);
4191
4192 #if 0
4193   /* Get out of template binding levels */
4194   while (b->pseudo_global)
4195     b = b->level_chain;
4196 #endif
4197
4198   pushdecl_with_scope (x, b);
4199 }
4200 #endif
4201
4202 /* Make the declaration(s) of X appear in CLASS scope
4203    under the name NAME.  */
4204
4205 void
4206 push_class_level_binding (name, x)
4207      tree name;
4208      tree x;
4209 {
4210   tree binding;
4211   /* The class_binding_level will be NULL if x is a template
4212      parameter name in a member template.  */
4213   if (!class_binding_level)
4214     return;
4215
4216   /* Make sure that this new member does not have the same name
4217      as a template parameter.  */
4218   if (TYPE_BEING_DEFINED (current_class_type))
4219     check_template_shadow (x);
4220
4221   /* If this declaration shadows a declaration from an enclosing
4222      class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4223      we leave this class.  Record the shadowed declaration here.  */
4224   binding = IDENTIFIER_BINDING (name);
4225   if (binding
4226       && ((TREE_CODE (x) == OVERLOAD
4227            && BINDING_VALUE (binding)
4228            && is_overloaded_fn (BINDING_VALUE (binding)))
4229           || INHERITED_VALUE_BINDING_P (binding)))
4230     {
4231       tree shadow;
4232       tree old_decl;
4233
4234       /* If the old binding was from a base class, and was for a tag
4235          name, slide it over to make room for the new binding.  The
4236          old binding is still visible if explicitly qualified with a
4237          class-key.  */
4238       if (INHERITED_VALUE_BINDING_P (binding)
4239           && BINDING_VALUE (binding)
4240           && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4241           && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4242           && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4243         {
4244           old_decl = BINDING_TYPE (binding);
4245           BINDING_TYPE (binding) = BINDING_VALUE (binding);
4246           BINDING_VALUE (binding) = NULL_TREE;
4247           INHERITED_VALUE_BINDING_P (binding) = 0;
4248         }
4249       else
4250         old_decl = BINDING_VALUE (binding);
4251
4252       /* There was already a binding for X containing fewer
4253          functions than are named in X.  Find the previous
4254          declaration of X on the class-shadowed list, and update it.  */
4255       for (shadow = class_binding_level->class_shadowed;
4256            shadow;
4257            shadow = TREE_CHAIN (shadow))
4258         if (TREE_PURPOSE (shadow) == name
4259             && TREE_TYPE (shadow) == old_decl)
4260           {
4261             BINDING_VALUE (binding) = x;
4262             INHERITED_VALUE_BINDING_P (binding) = 0;
4263             TREE_TYPE (shadow) = x;
4264             return;
4265           }
4266     }
4267
4268   /* If we didn't replace an existing binding, put the binding on the
4269      stack of bindings for the identifier, and update
4270      IDENTIFIER_CLASS_VALUE.  */
4271   if (push_class_binding (name, x))
4272     {
4273       class_binding_level->class_shadowed
4274         = tree_cons (name, IDENTIFIER_CLASS_VALUE (name),
4275                      class_binding_level->class_shadowed);
4276       /* Record the value we are binding NAME to so that we can know
4277          what to pop later.  */
4278       TREE_TYPE (class_binding_level->class_shadowed) = x;
4279     }
4280 }
4281
4282 /* Insert another USING_DECL into the current binding level,
4283    returning this declaration. If this is a redeclaration,
4284    do nothing and return NULL_TREE.  */
4285
4286 tree
4287 push_using_decl (scope, name)
4288      tree scope;
4289      tree name;
4290 {
4291   tree decl;
4292
4293   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4294   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4295   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4296     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4297       break;
4298   if (decl)
4299     return NULL_TREE;
4300   decl = build_lang_decl (USING_DECL, name, void_type_node);
4301   DECL_INITIAL (decl) = scope;
4302   TREE_CHAIN (decl) = current_binding_level->usings;
4303   current_binding_level->usings = decl;
4304   return decl;
4305 }
4306
4307 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4308    changed (i.e. there was already a directive), or the fresh
4309    TREE_LIST otherwise.  */
4310
4311 tree
4312 push_using_directive (used)
4313      tree used;
4314 {
4315   tree ud = current_binding_level->using_directives;
4316   tree iter, ancestor;
4317
4318   /* Check if we already have this. */
4319   if (purpose_member (used, ud) != NULL_TREE)
4320     return NULL_TREE;
4321
4322   /* Recursively add all namespaces used. */
4323   for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4324     push_using_directive (TREE_PURPOSE (iter));
4325
4326   ancestor = namespace_ancestor (current_decl_namespace (), used);
4327   ud = current_binding_level->using_directives;
4328   ud = tree_cons (used, ancestor, ud);
4329   current_binding_level->using_directives = ud;
4330   return ud;
4331 }
4332
4333 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4334    other definitions already in place.  We get around this by making
4335    the value of the identifier point to a list of all the things that
4336    want to be referenced by that name.  It is then up to the users of
4337    that name to decide what to do with that list.
4338
4339    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its DECL_RESULT
4340    slot.  It is dealt with the same way.
4341
4342    FLAGS is a bitwise-or of the following values:
4343      PUSH_LOCAL: Bind DECL in the current scope, rather than at
4344                  namespace scope.
4345      PUSH_USING: DECL is being pushed as the result of a using
4346                  declaration.
4347
4348    The value returned may be a previous declaration if we guessed wrong
4349    about what language DECL should belong to (C or C++).  Otherwise,
4350    it's always DECL (and never something that's not a _DECL).  */
4351
4352 tree
4353 push_overloaded_decl (decl, flags)
4354      tree decl;
4355      int flags;
4356 {
4357   tree name = DECL_NAME (decl);
4358   tree old;
4359   tree new_binding;
4360   int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4361
4362   if (doing_global)
4363     old = namespace_binding (name, DECL_CONTEXT (decl));
4364   else
4365     old = lookup_name_current_level (name);
4366
4367   if (old)
4368     {
4369       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4370         {
4371           tree t = TREE_TYPE (old);
4372           if (IS_AGGR_TYPE (t) && warn_shadow
4373               && (! DECL_IN_SYSTEM_HEADER (decl)
4374                   || ! DECL_IN_SYSTEM_HEADER (old)))
4375             cp_warning ("`%#D' hides constructor for `%#T'", decl, t);
4376           old = NULL_TREE;
4377         }
4378       else if (is_overloaded_fn (old))
4379         {
4380           tree tmp;
4381
4382           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4383             {
4384               tree fn = OVL_CURRENT (tmp);
4385
4386               if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4387                   && !(flags & PUSH_USING)
4388                   && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4389                                 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4390                 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4391                           decl, fn);
4392
4393               if (duplicate_decls (decl, fn))
4394                 return fn;
4395             }
4396         }
4397       else
4398         {
4399           cp_error_at ("previous non-function declaration `%#D'", old);
4400           cp_error ("conflicts with function declaration `%#D'", decl);
4401           return decl;
4402         }
4403     }
4404
4405   if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4406     {
4407       if (old && TREE_CODE (old) != OVERLOAD)
4408         new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4409       else
4410         new_binding = ovl_cons (decl, old);
4411       if (flags & PUSH_USING)
4412         OVL_USED (new_binding) = 1;
4413     }
4414   else
4415     /* NAME is not ambiguous.  */
4416     new_binding = decl;
4417
4418   if (doing_global)
4419     set_namespace_binding (name, current_namespace, new_binding);
4420   else
4421     {
4422       /* We only create an OVERLOAD if there was a previous binding at
4423          this level, or if decl is a template. In the former case, we
4424          need to remove the old binding and replace it with the new
4425          binding.  We must also run through the NAMES on the binding
4426          level where the name was bound to update the chain.  */
4427
4428       if (TREE_CODE (new_binding) == OVERLOAD && old)
4429         {
4430           tree *d;
4431
4432           for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4433                *d;
4434                d = &TREE_CHAIN (*d))
4435             if (*d == old
4436                 || (TREE_CODE (*d) == TREE_LIST
4437                     && TREE_VALUE (*d) == old))
4438               {
4439                 if (TREE_CODE (*d) == TREE_LIST)
4440                   /* Just replace the old binding with the new.  */
4441                   TREE_VALUE (*d) = new_binding;
4442                 else
4443                   /* Build a TREE_LIST to wrap the OVERLOAD.  */
4444                   *d = tree_cons (NULL_TREE, new_binding,
4445                                   TREE_CHAIN (*d));
4446
4447                 /* And update the CPLUS_BINDING node.  */
4448                 BINDING_VALUE (IDENTIFIER_BINDING (name))
4449                   = new_binding;
4450                 return decl;
4451               }
4452
4453           /* We should always find a previous binding in this case.  */
4454           my_friendly_abort (0);
4455         }
4456
4457       /* Install the new binding.  */
4458       push_local_binding (name, new_binding, flags);
4459     }
4460
4461   return decl;
4462 }
4463 \f
4464 /* Generate an implicit declaration for identifier FUNCTIONID
4465    as a function of type int ().  Print a warning if appropriate.  */
4466
4467 tree
4468 implicitly_declare (functionid)
4469      tree functionid;
4470 {
4471   register tree decl;
4472   int temp = allocation_temporary_p ();
4473
4474   push_obstacks_nochange ();
4475
4476   /* Save the decl permanently so we can warn if definition follows.
4477      In ANSI C, warn_implicit is usually false, so the saves little space.
4478      But in C++, it's usually true, hence the extra code.  */
4479   if (temp && (! warn_implicit || toplevel_bindings_p ()))
4480     end_temporary_allocation ();
4481
4482   /* We used to reuse an old implicit decl here,
4483      but this loses with inline functions because it can clobber
4484      the saved decl chains.  */
4485   decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4486
4487   DECL_EXTERNAL (decl) = 1;
4488   TREE_PUBLIC (decl) = 1;
4489
4490   /* ANSI standard says implicit declarations are in the innermost block.
4491      So we record the decl in the standard fashion.  */
4492   pushdecl (decl);
4493   rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
4494
4495   if (warn_implicit
4496       /* Only one warning per identifier.  */
4497       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4498     {
4499       cp_pedwarn ("implicit declaration of function `%#D'", decl);
4500     }
4501
4502   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4503
4504   pop_obstacks ();
4505
4506   return decl;
4507 }
4508
4509 /* Return zero if the declaration NEWDECL is valid
4510    when the declaration OLDDECL (assumed to be for the same name)
4511    has already been seen.
4512    Otherwise return an error message format string with a %s
4513    where the identifier should go.  */
4514
4515 static const char *
4516 redeclaration_error_message (newdecl, olddecl)
4517      tree newdecl, olddecl;
4518 {
4519   if (TREE_CODE (newdecl) == TYPE_DECL)
4520     {
4521       /* Because C++ can put things into name space for free,
4522          constructs like "typedef struct foo { ... } foo"
4523          would look like an erroneous redeclaration.  */
4524       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4525         return 0;
4526       else
4527         return "redefinition of `%#D'";
4528     }
4529   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4530     {
4531       /* If this is a pure function, its olddecl will actually be
4532          the original initialization to `0' (which we force to call
4533          abort()).  Don't complain about redefinition in this case.  */
4534       if (DECL_LANG_SPECIFIC (olddecl) && DECL_ABSTRACT_VIRTUAL_P (olddecl))
4535         return 0;
4536
4537       /* If both functions come from different namespaces, this is not
4538          a redeclaration - this is a conflict with a used function. */
4539       if (DECL_NAMESPACE_SCOPE_P (olddecl)
4540           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4541         return "`%D' conflicts with used function";
4542
4543       /* We'll complain about linkage mismatches in
4544          warn_extern_redeclared_static.  */
4545
4546       /* Defining the same name twice is no good.  */
4547       if (DECL_INITIAL (olddecl) != NULL_TREE
4548           && DECL_INITIAL (newdecl) != NULL_TREE)
4549         {
4550           if (DECL_NAME (olddecl) == NULL_TREE)
4551             return "`%#D' not declared in class";
4552           else
4553             return "redefinition of `%#D'";
4554         }
4555       return 0;
4556     }
4557   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4558     {
4559       if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4560            && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4561            && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4562           || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4563               && TYPE_SIZE (TREE_TYPE (newdecl))
4564               && TYPE_SIZE (TREE_TYPE (olddecl))))
4565         return "redefinition of `%#D'";
4566       return 0;
4567     }
4568   else if (toplevel_bindings_p ())
4569     {
4570       /* Objects declared at top level:  */
4571       /* If at least one is a reference, it's ok.  */
4572       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4573         return 0;
4574       /* Reject two definitions.  */
4575       return "redefinition of `%#D'";
4576     }
4577   else
4578     {
4579       /* Objects declared with block scope:  */
4580       /* Reject two definitions, and reject a definition
4581          together with an external reference.  */
4582       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4583         return "redeclaration of `%#D'";
4584       return 0;
4585     }
4586 }
4587 \f
4588 /* Create a new label, named ID.  */
4589
4590 static tree
4591 make_label_decl (id, local_p)
4592      tree id;
4593      int local_p;
4594 {
4595   tree decl;
4596
4597   decl = build_decl (LABEL_DECL, id, void_type_node);
4598   if (expanding_p)
4599     /* Make sure every label has an rtx.  */
4600     label_rtx (decl);
4601
4602   DECL_CONTEXT (decl) = current_function_decl;
4603   DECL_MODE (decl) = VOIDmode;
4604   C_DECLARED_LABEL_FLAG (decl) = local_p;
4605
4606   /* Say where one reference is to the label, for the sake of the
4607      error if it is not defined.  */
4608   DECL_SOURCE_LINE (decl) = lineno;
4609   DECL_SOURCE_FILE (decl) = input_filename;
4610
4611   /* Record the fact that this identifier is bound to this label.  */
4612   SET_IDENTIFIER_LABEL_VALUE (id, decl);
4613
4614   /* Record this label on the list of used labels so that we can check
4615      at the end of the function to see whether or not the label was
4616      actually defined.  */
4617   if ((named_label_uses == NULL || named_label_uses->label_decl != decl)
4618       && (named_label_uses == NULL
4619           || named_label_uses->names_in_scope != current_binding_level->names
4620           || named_label_uses->label_decl != decl))
4621     {
4622       struct named_label_list *new_ent;
4623       new_ent
4624         = (struct named_label_list*)oballoc (sizeof (struct named_label_list));
4625       new_ent->label_decl = decl;
4626       new_ent->names_in_scope = current_binding_level->names;
4627       new_ent->binding_level = current_binding_level;
4628       new_ent->lineno_o_goto = lineno;
4629       new_ent->filename_o_goto = input_filename;
4630       new_ent->next = named_label_uses;
4631       named_label_uses = new_ent;
4632     }
4633
4634   return decl;
4635 }
4636
4637 /* Look for a label named ID in the current function.  If one cannot
4638    be found, create one.  (We keep track of used, but undefined,
4639    labels, and complain about them at the end of a function.)  */
4640
4641 tree
4642 lookup_label (id)
4643      tree id;
4644 {
4645   tree decl;
4646
4647   /* You can't use labels at global scope.  */
4648   if (current_function_decl == NULL_TREE)
4649     {
4650       error ("label `%s' referenced outside of any function",
4651              IDENTIFIER_POINTER (id));
4652       return NULL_TREE;
4653     }
4654
4655   /* See if we've already got this label.  */
4656   decl = IDENTIFIER_LABEL_VALUE (id);
4657   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4658     return decl;
4659
4660   /* Record this label on the list of labels used in this function.
4661      We do this before calling make_label_decl so that we get the
4662      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
4663   named_labels = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4664                             named_labels);
4665   /* We need a new label.  */
4666   decl = make_label_decl (id, /*local_p=*/0);
4667   /* Now fill in the information we didn't have before.  */
4668   TREE_VALUE (named_labels) = decl;
4669
4670   return decl;
4671 }
4672
4673 /* Declare a local label named ID.  */
4674
4675 tree
4676 declare_local_label (id)
4677      tree id;
4678 {
4679   tree decl;
4680
4681   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4682      this scope we can restore the old value of
4683      IDENTIFIER_TYPE_VALUE.  */
4684   current_binding_level->shadowed_labels
4685     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4686                  current_binding_level->shadowed_labels);
4687   /* Look for the label.  */
4688   decl = make_label_decl (id, /*local_p=*/1);
4689   /* Now fill in the information we didn't have before.  */
4690   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4691
4692   return decl;
4693 }
4694
4695 /* Define a label, specifying the location in the source file.
4696    Return the LABEL_DECL node for the label, if the definition is valid.
4697    Otherwise return 0.  */
4698
4699 tree
4700 define_label (filename, line, name)
4701      char *filename;
4702      int line;
4703      tree name;
4704 {
4705   tree decl = lookup_label (name);
4706
4707   /* After labels, make any new cleanups go into their
4708      own new (temporary) binding contour.  */
4709   current_binding_level->more_cleanups_ok = 0;
4710
4711   if (name == get_identifier ("wchar_t"))
4712     cp_pedwarn ("label named wchar_t");
4713
4714   if (DECL_INITIAL (decl) != NULL_TREE)
4715     {
4716       cp_error ("duplicate label `%D'", decl);
4717       return 0;
4718     }
4719   else
4720     {
4721       struct named_label_list *uses, *prev;
4722       int identified = 0;
4723       int saw_eh = 0;
4724
4725       /* Mark label as having been defined.  */
4726       DECL_INITIAL (decl) = error_mark_node;
4727       /* Say where in the source.  */
4728       DECL_SOURCE_FILE (decl) = filename;
4729       DECL_SOURCE_LINE (decl) = line;
4730
4731       prev = NULL;
4732       uses = named_label_uses;
4733       while (uses != NULL)
4734         if (uses->label_decl == decl)
4735           {
4736             struct binding_level *b = current_binding_level;
4737             while (b)
4738               {
4739                 tree new_decls = b->names;
4740                 tree old_decls = (b == uses->binding_level)
4741                                   ? uses->names_in_scope : NULL_TREE;
4742                 while (new_decls != old_decls)
4743                   {
4744                     if (TREE_CODE (new_decls) == VAR_DECL
4745                         /* Don't complain about crossing initialization
4746                            of internal entities.  They can't be accessed,
4747                            and they should be cleaned up
4748                            by the time we get to the label.  */
4749                         && ! DECL_ARTIFICIAL (new_decls)
4750                         && !(DECL_INITIAL (new_decls) == NULL_TREE
4751                              && pod_type_p (TREE_TYPE (new_decls))))
4752                       {
4753                         /* This is really only important if we're crossing
4754                            an initialization.  The POD stuff is just
4755                            pedantry; why should it matter if the class
4756                            contains a field of pointer to member type?  */
4757                         int problem = (DECL_INITIAL (new_decls)
4758                                        || (TYPE_NEEDS_CONSTRUCTING
4759                                            (TREE_TYPE (new_decls))));
4760
4761                         if (! identified)
4762                           {
4763                             if (problem)
4764                               {
4765                                 cp_error ("jump to label `%D'", decl);
4766                                 error_with_file_and_line
4767                                   (uses->filename_o_goto,
4768                                    uses->lineno_o_goto, "  from here");
4769                               }
4770                             else
4771                               {
4772                                 cp_pedwarn ("jump to label `%D'", decl);
4773                                 pedwarn_with_file_and_line
4774                                   (uses->filename_o_goto,
4775                                    uses->lineno_o_goto, "  from here");
4776                               }
4777                             identified = 1;
4778                           }
4779
4780                         if (problem)
4781                           cp_error_at ("  crosses initialization of `%#D'",
4782                                        new_decls);
4783                         else
4784                           cp_pedwarn_at ("  enters scope of non-POD `%#D'",
4785                                          new_decls);
4786                       }
4787                     new_decls = TREE_CHAIN (new_decls);
4788                   }
4789                 if (b == uses->binding_level)
4790                   break;
4791                 if (b->eh_region && ! saw_eh)
4792                   {
4793                     if (! identified)
4794                       {
4795                         cp_error ("jump to label `%D'", decl);
4796                         error_with_file_and_line
4797                           (uses->filename_o_goto,
4798                            uses->lineno_o_goto, "  from here");
4799                         identified = 1;
4800                       }
4801                     error ("  enters exception handling block");
4802                     saw_eh = 1;
4803                   }
4804                 b = b->level_chain;
4805               }
4806
4807             if (prev != NULL)
4808               prev->next = uses->next;
4809             else
4810               named_label_uses = uses->next;
4811
4812             uses = uses->next;
4813           }
4814         else
4815           {
4816             prev = uses;
4817             uses = uses->next;
4818           }
4819       current_function_return_value = NULL_TREE;
4820       return decl;
4821     }
4822 }
4823
4824 struct cp_switch
4825 {
4826   struct binding_level *level;
4827   struct cp_switch *next;
4828 };
4829
4830 static struct cp_switch *switch_stack;
4831
4832 void
4833 push_switch ()
4834 {
4835   struct cp_switch *p
4836     = (struct cp_switch *) oballoc (sizeof (struct cp_switch));
4837   p->level = current_binding_level;
4838   p->next = switch_stack;
4839   switch_stack = p;
4840 }
4841
4842 void
4843 pop_switch ()
4844 {
4845   switch_stack = switch_stack->next;
4846 }
4847
4848 /* Note that we've seen a definition of a case label, and complain if this
4849    is a bad place for one.  */
4850
4851 void
4852 define_case_label ()
4853 {
4854   tree cleanup = last_cleanup_this_contour ();
4855   struct binding_level *b = current_binding_level;
4856   int identified = 0;
4857
4858   if (! switch_stack)
4859     /* Don't crash; we'll complain in do_case.  */
4860     return;
4861
4862   if (cleanup)
4863     {
4864       static int explained = 0;
4865       cp_warning_at ("destructor needed for `%#D'", TREE_PURPOSE (cleanup));
4866       warning ("where case label appears here");
4867       if (!explained)
4868         {
4869           warning ("(enclose actions of previous case statements requiring");
4870           warning ("destructors in their own binding contours.)");
4871           explained = 1;
4872         }
4873     }
4874
4875   for (; b && b != switch_stack->level; b = b->level_chain)
4876     {
4877       tree new_decls = b->names;
4878       for (; new_decls; new_decls = TREE_CHAIN (new_decls))
4879         {
4880           if (TREE_CODE (new_decls) == VAR_DECL
4881               /* Don't complain about crossing initialization
4882                  of internal entities.  They can't be accessed,
4883                  and they should be cleaned up
4884                  by the time we get to the label.  */
4885               && ! DECL_ARTIFICIAL (new_decls)
4886               && ((DECL_INITIAL (new_decls) != NULL_TREE
4887                    && DECL_INITIAL (new_decls) != error_mark_node)
4888                   || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (new_decls))))
4889             {
4890               if (! identified)
4891                 error ("jump to case label");
4892               identified = 1;
4893               cp_error_at ("  crosses initialization of `%#D'",
4894                            new_decls);
4895             }
4896         }
4897     }
4898
4899   /* After labels, make any new cleanups go into their
4900      own new (temporary) binding contour.  */
4901
4902   current_binding_level->more_cleanups_ok = 0;
4903   current_function_return_value = NULL_TREE;
4904 }
4905 \f
4906 /* Return the list of declarations of the current level.
4907    Note that this list is in reverse order unless/until
4908    you nreverse it; and when you do nreverse it, you must
4909    store the result back using `storedecls' or you will lose.  */
4910
4911 tree
4912 getdecls ()
4913 {
4914   return current_binding_level->names;
4915 }
4916
4917 /* Return the list of type-tags (for structs, etc) of the current level.  */
4918
4919 tree
4920 gettags ()
4921 {
4922   return current_binding_level->tags;
4923 }
4924
4925 /* Store the list of declarations of the current level.
4926    This is done for the parameter declarations of a function being defined,
4927    after they are modified in the light of any missing parameters.  */
4928
4929 static void
4930 storedecls (decls)
4931      tree decls;
4932 {
4933   current_binding_level->names = decls;
4934 }
4935
4936 /* Similarly, store the list of tags of the current level.  */
4937
4938 void
4939 storetags (tags)
4940      tree tags;
4941 {
4942   current_binding_level->tags = tags;
4943 }
4944 \f
4945 /* Given NAME, an IDENTIFIER_NODE,
4946    return the structure (or union or enum) definition for that name.
4947    Searches binding levels from BINDING_LEVEL up to the global level.
4948    If THISLEVEL_ONLY is nonzero, searches only the specified context
4949    (but skips any tag-transparent contexts to find one that is
4950    meaningful for tags).
4951    FORM says which kind of type the caller wants;
4952    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
4953    If the wrong kind of type is found, and it's not a template, an error is
4954    reported.  */
4955
4956 static tree
4957 lookup_tag (form, name, binding_level, thislevel_only)
4958      enum tree_code form;
4959      tree name;
4960      struct binding_level *binding_level;
4961      int thislevel_only;
4962 {
4963   register struct binding_level *level;
4964   /* Non-zero if, we should look past a pseudo-global level, even if
4965      THISLEVEL_ONLY.  */
4966   int allow_pseudo_global = 1;
4967
4968   for (level = binding_level; level; level = level->level_chain)
4969     {
4970       register tree tail;
4971       if (ANON_AGGRNAME_P (name))
4972         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
4973           {
4974             /* There's no need for error checking here, because
4975                anon names are unique throughout the compilation.  */
4976             if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
4977               return TREE_VALUE (tail);
4978           }
4979       else if (level->namespace_p)
4980         /* Do namespace lookup. */
4981         for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
4982           {
4983             tree old = binding_for_name (name, tail);
4984
4985             /* If we just skipped past a pseudo global level, even
4986                though THISLEVEL_ONLY, and we find a template class
4987                declaration, then we use the _TYPE node for the
4988                template.  See the example below.  */
4989             if (thislevel_only && !allow_pseudo_global
4990                 && old && BINDING_VALUE (old)
4991                 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
4992               old = TREE_TYPE (BINDING_VALUE (old));
4993             else
4994               old = BINDING_TYPE (old);
4995
4996             /* If it has an original type, it is a typedef, and we
4997                should not return it.  */
4998             if (old && DECL_ORIGINAL_TYPE (TYPE_NAME (old)))
4999               old = NULL_TREE;
5000             if (old && TREE_CODE (old) != form
5001                 && !(form != ENUMERAL_TYPE && TREE_CODE (old) == TEMPLATE_DECL))
5002               {
5003                 cp_error ("`%#D' redeclared as %C", old, form);
5004                 return NULL_TREE;
5005               }
5006             if (old)
5007               return old;
5008             if (thislevel_only || tail == global_namespace)
5009               return NULL_TREE;
5010           }
5011       else
5012         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5013           {
5014             if (TREE_PURPOSE (tail) == name)
5015               {
5016                 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5017                 /* Should tighten this up; it'll probably permit
5018                    UNION_TYPE and a struct template, for example.  */
5019                 if (code != form
5020                     && !(form != ENUMERAL_TYPE && code == TEMPLATE_DECL))
5021                   {
5022                     /* Definition isn't the kind we were looking for.  */
5023                     cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
5024                               form);
5025                     return NULL_TREE;
5026                   }
5027                 return TREE_VALUE (tail);
5028               }
5029           }
5030       if (thislevel_only && ! level->tag_transparent)
5031         {
5032           if (level->pseudo_global && allow_pseudo_global)
5033             {
5034               /* We must deal with cases like this:
5035
5036                    template <class T> struct S;
5037                    template <class T> struct S {};
5038
5039                  When looking up `S', for the second declaration, we
5040                  would like to find the first declaration.  But, we
5041                  are in the pseudo-global level created for the
5042                  template parameters, rather than the (surrounding)
5043                  namespace level.  Thus, we keep going one more level,
5044                  even though THISLEVEL_ONLY is non-zero.  */
5045               allow_pseudo_global = 0;
5046               continue;
5047             }
5048           else
5049             return NULL_TREE;
5050         }
5051     }
5052   return NULL_TREE;
5053 }
5054
5055 #if 0
5056 void
5057 set_current_level_tags_transparency (tags_transparent)
5058      int tags_transparent;
5059 {
5060   current_binding_level->tag_transparent = tags_transparent;
5061 }
5062 #endif
5063
5064 /* Given a type, find the tag that was defined for it and return the tag name.
5065    Otherwise return 0.  However, the value can never be 0
5066    in the cases in which this is used.
5067
5068    C++: If NAME is non-zero, this is the new name to install.  This is
5069    done when replacing anonymous tags with real tag names.  */
5070
5071 static tree
5072 lookup_tag_reverse (type, name)
5073      tree type;
5074      tree name;
5075 {
5076   register struct binding_level *level;
5077
5078   for (level = current_binding_level; level; level = level->level_chain)
5079     {
5080       register tree tail;
5081       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5082         {
5083           if (TREE_VALUE (tail) == type)
5084             {
5085               if (name)
5086                 TREE_PURPOSE (tail) = name;
5087               return TREE_PURPOSE (tail);
5088             }
5089         }
5090     }
5091   return NULL_TREE;
5092 }
5093 \f
5094 /* Look up NAME in the NAMESPACE.  */
5095
5096 tree
5097 lookup_namespace_name (namespace, name)
5098      tree namespace, name;
5099 {
5100   tree val;
5101   tree template_id = NULL_TREE;
5102
5103   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5104
5105   if (TREE_CODE (name) == NAMESPACE_DECL)
5106     /* This happens for A::B<int> when B is a namespace. */
5107     return name;
5108   else if (TREE_CODE (name) == TEMPLATE_DECL)
5109     {
5110       /* This happens for A::B where B is a template, and there are no
5111          template arguments.  */
5112       cp_error ("invalid use of `%D'", name);
5113       return error_mark_node;
5114     }
5115
5116   namespace = ORIGINAL_NAMESPACE (namespace);
5117
5118   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5119     {
5120       template_id = name;
5121       name = TREE_OPERAND (name, 0);
5122       if (TREE_CODE (name) == OVERLOAD)
5123         name = DECL_NAME (OVL_CURRENT (name));
5124       else if (TREE_CODE_CLASS (TREE_CODE (name)) == 'd')
5125         name = DECL_NAME (name);
5126     }
5127
5128   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5129
5130   val = make_node (CPLUS_BINDING);
5131   if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5132     return error_mark_node;
5133
5134   if (BINDING_VALUE (val))
5135     {
5136       val = BINDING_VALUE (val);
5137
5138       if (template_id)
5139         {
5140           if (DECL_CLASS_TEMPLATE_P (val))
5141             val = lookup_template_class (val,
5142                                          TREE_OPERAND (template_id, 1),
5143                                          /*in_decl=*/NULL_TREE,
5144                                          /*context=*/NULL_TREE,
5145                                          /*entering_scope=*/0);
5146           else if (DECL_FUNCTION_TEMPLATE_P (val)
5147                    || TREE_CODE (val) == OVERLOAD)
5148             val = lookup_template_function (val,
5149                                             TREE_OPERAND (template_id, 1));
5150           else
5151             {
5152               cp_error ("`%D::%D' is not a template",
5153                         namespace, name);
5154               return error_mark_node;
5155             }
5156         }
5157
5158       /* If we have a single function from a using decl, pull it out.  */
5159       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5160         val = OVL_FUNCTION (val);
5161       return val;
5162     }
5163
5164   cp_error ("`%D' undeclared in namespace `%D'", name, namespace);
5165   return error_mark_node;
5166 }
5167
5168 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
5169
5170 static unsigned long
5171 typename_hash (k)
5172      hash_table_key k;
5173 {
5174   unsigned long hash;
5175   tree t;
5176
5177   t = (tree) k;
5178   hash = (((unsigned long) TYPE_CONTEXT (t))
5179           ^ ((unsigned long) DECL_NAME (TYPE_NAME (t))));
5180
5181   return hash;
5182 }
5183
5184 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
5185
5186 static boolean
5187 typename_compare (k1, k2)
5188      hash_table_key k1;
5189      hash_table_key k2;
5190 {
5191   tree t1;
5192   tree t2;
5193   tree d1;
5194   tree d2;
5195
5196   t1 = (tree) k1;
5197   t2 = (tree) k2;
5198   d1 = TYPE_NAME (t1);
5199   d2 = TYPE_NAME (t2);
5200
5201   return (DECL_NAME (d1) == DECL_NAME (d2)
5202           && same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))
5203           && ((TREE_TYPE (t1) != NULL_TREE)
5204               == (TREE_TYPE (t2) != NULL_TREE))
5205           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5206           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5207 }
5208
5209 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
5210    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
5211    is non-NULL, this type is being created by the implicit typename
5212    extension, and BASE_TYPE is a type named `t' in some base class of
5213    `T' which depends on template parameters.
5214
5215    Returns the new TYPENAME_TYPE.  */
5216
5217 tree
5218 build_typename_type (context, name, fullname, base_type)
5219      tree context;
5220      tree name;
5221      tree fullname;
5222      tree base_type;
5223 {
5224   tree t;
5225   tree d;
5226   struct hash_entry* e;
5227
5228   static struct hash_table ht;
5229
5230   push_obstacks (&permanent_obstack, &permanent_obstack);
5231
5232   if (!ht.table)
5233     {
5234       static struct hash_table *h = &ht;
5235       if (!hash_table_init (&ht, &hash_newfunc, &typename_hash,
5236                             &typename_compare))
5237         fatal ("virtual memory exhausted");
5238       ggc_add_tree_hash_table_root (&h, 1);
5239     }
5240
5241   /* Build the TYPENAME_TYPE.  */
5242   t = make_lang_type (TYPENAME_TYPE);
5243   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5244   TYPENAME_TYPE_FULLNAME (t) = fullname;
5245   TREE_TYPE (t) = base_type;
5246
5247   /* Build the corresponding TYPE_DECL.  */
5248   d = build_decl (TYPE_DECL, name, t);
5249   TYPE_NAME (TREE_TYPE (d)) = d;
5250   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5251   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5252   DECL_ARTIFICIAL (d) = 1;
5253
5254   /* See if we already have this type.  */
5255   e = hash_lookup (&ht, t, /*create=*/false, /*copy=*/0);
5256   if (e)
5257     t = (tree) e->key;
5258   else
5259     /* Insert the type into the table.  */
5260     hash_lookup (&ht, t, /*create=*/true, /*copy=*/0);
5261
5262   pop_obstacks ();
5263
5264   return t;
5265 }
5266
5267 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
5268    unless an error occurs, in which case error_mark_node is returned.
5269    If COMPLAIN zero, don't complain about any errors that occur.  */
5270
5271 tree
5272 make_typename_type (context, name, complain)
5273      tree context, name;
5274      int complain;
5275 {
5276   tree fullname;
5277
5278   if (TREE_CODE_CLASS (TREE_CODE (name)) == 't')
5279     {
5280       if (!(TYPE_LANG_SPECIFIC (name)
5281             && (CLASSTYPE_IS_TEMPLATE (name)
5282                 || CLASSTYPE_USE_TEMPLATE (name))))
5283         name = TYPE_IDENTIFIER (name);
5284       else
5285         /* Create a TEMPLATE_ID_EXPR for the type.  */
5286         name = build_nt (TEMPLATE_ID_EXPR,
5287                          CLASSTYPE_TI_TEMPLATE (name),
5288                          CLASSTYPE_TI_ARGS (name));
5289     }
5290   else if (TREE_CODE (name) == TYPE_DECL)
5291     name = DECL_NAME (name);
5292
5293   fullname = name;
5294
5295   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5296     {
5297       name = TREE_OPERAND (name, 0);
5298       if (TREE_CODE (name) == TEMPLATE_DECL)
5299         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5300     }
5301   if (TREE_CODE (name) != IDENTIFIER_NODE)
5302     my_friendly_abort (2000);
5303
5304   if (TREE_CODE (context) == NAMESPACE_DECL)
5305     {
5306       /* We can get here from typename_sub0 in the explicit_template_type
5307          expansion.  Just fail.  */
5308       if (complain)
5309         cp_error ("no class template named `%#T' in `%#T'",
5310                   name, context);
5311       return error_mark_node;
5312     }
5313
5314   if (! uses_template_parms (context)
5315       || currently_open_class (context))
5316     {
5317       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5318         {
5319           tree tmpl = NULL_TREE;
5320           if (IS_AGGR_TYPE (context))
5321             tmpl = lookup_field (context, name, 0, 0);
5322           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5323             {
5324               if (complain)
5325                 cp_error ("no class template named `%#T' in `%#T'",
5326                           name, context);
5327               return error_mark_node;
5328             }
5329
5330           return lookup_template_class (tmpl,
5331                                         TREE_OPERAND (fullname, 1),
5332                                         NULL_TREE, context,
5333                                         /*entering_scope=*/0);
5334         }
5335       else
5336         {
5337           tree t;
5338
5339           if (!IS_AGGR_TYPE (context))
5340             {
5341               if (complain)
5342                 cp_error ("no type named `%#T' in `%#T'", name, context);
5343               return error_mark_node;
5344             }
5345
5346           t = lookup_field (context, name, 0, 1);
5347           if (t)
5348             return TREE_TYPE (t);
5349         }
5350     }
5351
5352   /* If the CONTEXT is not a template type, then either the field is
5353      there now or its never going to be.  */
5354   if (!uses_template_parms (context))
5355     {
5356       if (complain)
5357         cp_error ("no type named `%#T' in `%#T'", name, context);
5358       return error_mark_node;
5359     }
5360
5361
5362   return build_typename_type (context, name, fullname,  NULL_TREE);
5363 }
5364
5365 /* Select the right _DECL from multiple choices. */
5366
5367 static tree
5368 select_decl (binding, flags)
5369      tree binding;
5370      int flags;
5371 {
5372   tree val;
5373   val = BINDING_VALUE (binding);
5374   if (LOOKUP_NAMESPACES_ONLY (flags))
5375     {
5376       /* We are not interested in types. */
5377       if (val && TREE_CODE (val) == NAMESPACE_DECL)
5378         return val;
5379       return NULL_TREE;
5380     }
5381
5382   /* If we could have a type and
5383      we have nothing or we need a type and have none.  */
5384   if (BINDING_TYPE (binding)
5385       && (!val || ((flags & LOOKUP_PREFER_TYPES)
5386                    && TREE_CODE (val) != TYPE_DECL)))
5387     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5388   /* Don't return non-types if we really prefer types. */
5389   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
5390            && (TREE_CODE (val) != TEMPLATE_DECL
5391                || !DECL_CLASS_TEMPLATE_P (val)))
5392     val = NULL_TREE;
5393
5394   return val;
5395 }
5396
5397 /* Unscoped lookup of a global: iterate over current namespaces,
5398    considering using-directives.  If SPACESP is non-NULL, store a list
5399    of the namespaces we've considered in it.  */
5400
5401 tree
5402 unqualified_namespace_lookup (name, flags, spacesp)
5403      tree name;
5404      int flags;
5405      tree *spacesp;
5406 {
5407   tree b = make_node (CPLUS_BINDING);
5408   tree initial = current_decl_namespace();
5409   tree scope = initial;
5410   tree siter;
5411   struct binding_level *level;
5412   tree val = NULL_TREE;
5413
5414   if (spacesp)
5415     *spacesp = NULL_TREE;
5416
5417   for (; !val; scope = CP_DECL_CONTEXT (scope))
5418     {
5419       if (spacesp)
5420         *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5421       val = binding_for_name (name, scope);
5422
5423       /* Initialize binding for this context. */
5424       BINDING_VALUE (b) = BINDING_VALUE (val);
5425       BINDING_TYPE (b) = BINDING_TYPE (val);
5426
5427       /* Add all _DECLs seen through local using-directives. */
5428       for (level = current_binding_level;
5429            !level->namespace_p;
5430            level = level->level_chain)
5431         if (!lookup_using_namespace (name, b, level->using_directives,
5432                                      scope, flags, spacesp))
5433           /* Give up because of error. */
5434           return error_mark_node;
5435
5436       /* Add all _DECLs seen through global using-directives. */
5437       /* XXX local and global using lists should work equally. */
5438       siter = initial;
5439       while (1)
5440         {
5441           if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5442                                        scope, flags, spacesp))
5443             /* Give up because of error. */
5444             return error_mark_node;
5445           if (siter == scope) break;
5446           siter = CP_DECL_CONTEXT (siter);
5447         }
5448
5449       val = select_decl (b, flags);
5450       if (scope == global_namespace)
5451         break;
5452     }
5453   return val;
5454 }
5455
5456 /* Combine prefer_type and namespaces_only into flags.  */
5457
5458 static int
5459 lookup_flags (prefer_type, namespaces_only)
5460   int prefer_type, namespaces_only;
5461 {
5462   if (namespaces_only)
5463     return LOOKUP_PREFER_NAMESPACES;
5464   if (prefer_type > 1)
5465     return LOOKUP_PREFER_TYPES;
5466   if (prefer_type > 0)
5467     return LOOKUP_PREFER_BOTH;
5468   return 0;
5469 }
5470
5471 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5472    ignore it or not.  Subroutine of lookup_name_real.  */
5473
5474 static tree
5475 qualify_lookup (val, flags)
5476      tree val;
5477      int flags;
5478 {
5479   if (val == NULL_TREE)
5480     return val;
5481   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5482     return val;
5483   if ((flags & LOOKUP_PREFER_TYPES)
5484       && (TREE_CODE (val) == TYPE_DECL
5485           || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5486               && DECL_CLASS_TEMPLATE_P (val))))
5487     return val;
5488   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5489     return NULL_TREE;
5490   return val;
5491 }
5492
5493 /* Any other BINDING overrides an implicit TYPENAME.  Warn about
5494    that.  */
5495
5496 static void
5497 warn_about_implicit_typename_lookup (typename, binding)
5498      tree typename;
5499      tree binding;
5500 {
5501   tree subtype = TREE_TYPE (TREE_TYPE (typename));
5502   tree name = DECL_NAME (typename);
5503
5504   if (! (TREE_CODE (binding) == TEMPLATE_DECL
5505          && CLASSTYPE_TEMPLATE_INFO (subtype)
5506          && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
5507       && ! (TREE_CODE (binding) == TYPE_DECL
5508             && same_type_p (TREE_TYPE (binding), subtype)))
5509     {
5510       cp_warning ("lookup of `%D' finds `%#D'",
5511                   name, binding);
5512       cp_warning ("  instead of `%D' from dependent base class",
5513                   typename);
5514       cp_warning ("  (use `typename %T::%D' if that's what you meant)",
5515                   constructor_name (current_class_type), name);
5516     }
5517 }
5518
5519 /* Look up NAME in the current binding level and its superiors in the
5520    namespace of variables, functions and typedefs.  Return a ..._DECL
5521    node of some kind representing its definition if there is only one
5522    such declaration, or return a TREE_LIST with all the overloaded
5523    definitions if there are many, or return 0 if it is undefined.
5524
5525    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5526    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5527    If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5528    Otherwise we prefer non-TYPE_DECLs.
5529
5530    If NONCLASS is non-zero, we don't look for the NAME in class scope,
5531    using IDENTIFIER_CLASS_VALUE.  */
5532
5533 static tree
5534 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
5535      tree name;
5536      int prefer_type, nonclass, namespaces_only;
5537 {
5538   tree t;
5539   tree val = NULL_TREE;
5540   int yylex = 0;
5541   tree from_obj = NULL_TREE;
5542   int flags;
5543   int val_is_implicit_typename = 0;
5544
5545   /* Hack: copy flag set by parser, if set. */
5546   if (only_namespace_names)
5547     namespaces_only = 1;
5548
5549   if (prefer_type == -2)
5550     {
5551       extern int looking_for_typename;
5552       tree type = NULL_TREE;
5553
5554       yylex = 1;
5555       prefer_type = looking_for_typename;
5556
5557       flags = lookup_flags (prefer_type, namespaces_only);
5558       /* If the next thing is '<', class templates are types. */
5559       if (looking_for_template)
5560         flags |= LOOKUP_TEMPLATES_EXPECTED;
5561
5562       /* std:: becomes :: for now.  */
5563       if (got_scope == std_node)
5564         got_scope = void_type_node;
5565
5566       if (got_scope)
5567         type = got_scope;
5568       else if (got_object != error_mark_node)
5569         type = got_object;
5570
5571       if (type)
5572         {
5573           if (type == error_mark_node)
5574             return error_mark_node;
5575           if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
5576             type = TREE_TYPE (type);
5577
5578           if (TYPE_P (type))
5579             type = complete_type (type);
5580
5581           if (TREE_CODE (type) == VOID_TYPE)
5582             type = global_namespace;
5583           if (TREE_CODE (type) == NAMESPACE_DECL)
5584             {
5585               val = make_node (CPLUS_BINDING);
5586               flags |= LOOKUP_COMPLAIN;
5587               if (!qualified_lookup_using_namespace (name, type, val, flags))
5588                 return NULL_TREE;
5589               val = select_decl (val, flags);
5590             }
5591           else if (! IS_AGGR_TYPE (type)
5592                    || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5593                    || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM
5594                    || TREE_CODE (type) == TYPENAME_TYPE)
5595             /* Someone else will give an error about this if needed.  */
5596             val = NULL_TREE;
5597           else if (type == current_class_type)
5598             val = IDENTIFIER_CLASS_VALUE (name);
5599           else
5600             val = lookup_member (type, name, 0, prefer_type);
5601         }
5602       else
5603         val = NULL_TREE;
5604
5605       if (got_scope)
5606         goto done;
5607       else if (got_object && val)
5608         from_obj = val;
5609     }
5610   else
5611     {
5612       flags = lookup_flags (prefer_type, namespaces_only);
5613       /* If we're not parsing, we need to complain. */
5614       flags |= LOOKUP_COMPLAIN;
5615     }
5616
5617   /* First, look in non-namespace scopes.  */
5618
5619   if (current_class_type == NULL_TREE)
5620     nonclass = 1;
5621
5622   for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
5623     {
5624       tree binding;
5625
5626       if (!LOCAL_BINDING_P (t) && nonclass)
5627         /* We're not looking for class-scoped bindings, so keep going.  */
5628         continue;
5629
5630       /* If this is the kind of thing we're looking for, we're done.  */
5631       if (qualify_lookup (BINDING_VALUE (t), flags))
5632         binding = BINDING_VALUE (t);
5633       else if ((flags & LOOKUP_PREFER_TYPES)
5634                && qualify_lookup (BINDING_TYPE (t), flags))
5635         binding = BINDING_TYPE (t);
5636       else
5637         binding = NULL_TREE;
5638
5639       if (binding
5640           && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
5641         {
5642           if (val_is_implicit_typename && !yylex)
5643             warn_about_implicit_typename_lookup (val, binding);
5644           val = binding;
5645           val_is_implicit_typename
5646             = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
5647           if (!val_is_implicit_typename)
5648             break;
5649         }
5650     }
5651
5652   /* Now lookup in namespace scopes.  */
5653   if (!val || val_is_implicit_typename)
5654     {
5655       t = unqualified_namespace_lookup (name, flags, 0);
5656       if (t)
5657         {
5658           if (val_is_implicit_typename && !yylex)
5659             warn_about_implicit_typename_lookup (val, t);
5660           val = t;
5661         }
5662     }
5663
5664  done:
5665   if (val)
5666     {
5667       /* This should only warn about types used in qualified-ids.  */
5668       if (from_obj && from_obj != val)
5669         {
5670           if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
5671               && TREE_CODE (val) == TYPE_DECL
5672               && TREE_TYPE (from_obj) != TREE_TYPE (val))
5673             {
5674               cp_pedwarn ("lookup of `%D' in the scope of `%#T' (`%#T')",
5675                           name, got_object, TREE_TYPE (from_obj));
5676               cp_pedwarn ("  does not match lookup in the current scope (`%#T')",
5677                           TREE_TYPE (val));
5678             }
5679
5680           /* We don't change val to from_obj if got_object depends on
5681              template parms because that breaks implicit typename for
5682              destructor calls.  */
5683           if (! uses_template_parms (got_object))
5684             val = from_obj;
5685         }
5686
5687       /* If we have a single function from a using decl, pull it out.  */
5688       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5689         val = OVL_FUNCTION (val);
5690     }
5691   else if (from_obj)
5692     val = from_obj;
5693
5694   return val;
5695 }
5696
5697 tree
5698 lookup_name_nonclass (name)
5699      tree name;
5700 {
5701   return lookup_name_real (name, 0, 1, 0);
5702 }
5703
5704 tree
5705 lookup_function_nonclass (name, args)
5706      tree name;
5707      tree args;
5708 {
5709   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
5710 }
5711
5712 tree
5713 lookup_name_namespace_only (name)
5714      tree name;
5715 {
5716   /* type-or-namespace, nonclass, namespace_only */
5717   return lookup_name_real (name, 1, 1, 1);
5718 }
5719
5720 tree
5721 lookup_name (name, prefer_type)
5722      tree name;
5723      int prefer_type;
5724 {
5725   return lookup_name_real (name, prefer_type, 0, 0);
5726 }
5727
5728 /* Similar to `lookup_name' but look only in the innermost non-class
5729    binding level.  */
5730
5731 tree
5732 lookup_name_current_level (name)
5733      tree name;
5734 {
5735   struct binding_level *b;
5736   tree t = NULL_TREE;
5737
5738   b = current_binding_level;
5739   while (b->parm_flag == 2)
5740     b = b->level_chain;
5741
5742   if (b->namespace_p)
5743     {
5744       t = IDENTIFIER_NAMESPACE_VALUE (name);
5745
5746       /* extern "C" function() */
5747       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
5748         t = TREE_VALUE (t);
5749     }
5750   else if (IDENTIFIER_BINDING (name)
5751            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
5752     {
5753       while (1)
5754         {
5755           if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
5756             return IDENTIFIER_VALUE (name);
5757
5758           if (b->keep == 2)
5759             b = b->level_chain;
5760           else
5761             break;
5762         }
5763     }
5764
5765   return t;
5766 }
5767
5768 /* Like lookup_name_current_level, but for types.  */
5769
5770 tree
5771 lookup_type_current_level (name)
5772      tree name;
5773 {
5774   register tree t = NULL_TREE;
5775
5776   my_friendly_assert (! current_binding_level->namespace_p, 980716);
5777
5778   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
5779       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
5780     {
5781       struct binding_level *b = current_binding_level;
5782       while (1)
5783         {
5784           if (purpose_member (name, b->type_shadowed))
5785             return REAL_IDENTIFIER_TYPE_VALUE (name);
5786           if (b->keep == 2)
5787             b = b->level_chain;
5788           else
5789             break;
5790         }
5791     }
5792
5793   return t;
5794 }
5795
5796 void
5797 begin_only_namespace_names ()
5798 {
5799   only_namespace_names = 1;
5800 }
5801
5802 void
5803 end_only_namespace_names ()
5804 {
5805   only_namespace_names = 0;
5806 }
5807 \f
5808 /* Arrange for the user to get a source line number, even when the
5809    compiler is going down in flames, so that she at least has a
5810    chance of working around problems in the compiler.  We used to
5811    call error(), but that let the segmentation fault continue
5812    through; now, it's much more passive by asking them to send the
5813    maintainers mail about the problem.  */
5814
5815 static void
5816 signal_catch (sig)
5817      int sig ATTRIBUTE_UNUSED;
5818 {
5819   signal (SIGSEGV, SIG_DFL);
5820 #ifdef SIGIOT
5821   signal (SIGIOT, SIG_DFL);
5822 #endif
5823 #ifdef SIGILL
5824   signal (SIGILL, SIG_DFL);
5825 #endif
5826 #ifdef SIGABRT
5827   signal (SIGABRT, SIG_DFL);
5828 #endif
5829 #ifdef SIGBUS
5830   signal (SIGBUS, SIG_DFL);
5831 #endif
5832   my_friendly_abort (0);
5833 }
5834
5835 /* Push the declarations of builtin types into the namespace.
5836    RID_INDEX, if < RID_MAX is the index of the builtin type
5837    in the array RID_POINTERS.  NAME is the name used when looking
5838    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
5839
5840 static void
5841 record_builtin_type (rid_index, name, type)
5842      enum rid rid_index;
5843      const char *name;
5844      tree type;
5845 {
5846   tree rname = NULL_TREE, tname = NULL_TREE;
5847   tree tdecl = NULL_TREE;
5848
5849   if ((int) rid_index < (int) RID_MAX)
5850     rname = ridpointers[(int) rid_index];
5851   if (name)
5852     tname = get_identifier (name);
5853
5854   TYPE_BUILT_IN (type) = 1;
5855
5856   if (tname)
5857     {
5858       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
5859       set_identifier_type_value (tname, NULL_TREE);
5860       if ((int) rid_index < (int) RID_MAX)
5861         /* Built-in types live in the global namespace. */
5862         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
5863     }
5864   if (rname != NULL_TREE)
5865     {
5866       if (tname != NULL_TREE)
5867         {
5868           set_identifier_type_value (rname, NULL_TREE);
5869           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
5870         }
5871       else
5872         {
5873           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
5874           set_identifier_type_value (rname, NULL_TREE);
5875         }
5876     }
5877 }
5878
5879 /* Record one of the standard Java types.
5880  * Declare it as having the given NAME.
5881  * If SIZE > 0, it is the size of one of the integral types;
5882  * otherwise it is the negative of the size of one of the other types.  */
5883
5884 static tree
5885 record_builtin_java_type (name, size)
5886      const char *name;
5887      int size;
5888 {
5889   tree type, decl;
5890   if (size > 0)
5891     type = make_signed_type (size);
5892   else if (size > -32)
5893     { /* "__java_char" or ""__java_boolean". */
5894       type = make_unsigned_type (-size);
5895       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
5896     }
5897   else
5898     { /* "__java_float" or ""__java_double". */
5899       type = make_node (REAL_TYPE);
5900       TYPE_PRECISION (type) = - size;
5901       layout_type (type);
5902     }
5903   record_builtin_type (RID_MAX, name, type);
5904   decl = TYPE_NAME (type);
5905
5906   /* Suppress generate debug symbol entries for these types,
5907      since for normal C++ they are just clutter.
5908      However, push_lang_context undoes this if extern "Java" is seen. */
5909   DECL_IGNORED_P (decl) = 1;
5910
5911   TYPE_FOR_JAVA (type) = 1;
5912   return type;
5913 }
5914
5915 /* Push a type into the namespace so that the back-ends ignore it. */
5916
5917 static void
5918 record_unknown_type (type, name)
5919      tree type;
5920      const char *name;
5921 {
5922   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
5923   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
5924   DECL_IGNORED_P (decl) = 1;
5925   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
5926   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
5927   TYPE_ALIGN (type) = 1;
5928   TYPE_MODE (type) = TYPE_MODE (void_type_node);
5929 }
5930
5931 /* Push overloaded decl, in global scope, with one argument so it
5932    can be used as a callback from define_function.  */
5933
5934 static void
5935 push_overloaded_decl_1 (x)
5936      tree x;
5937 {
5938   pushdecl (x);
5939 }
5940
5941 inline tree
5942 auto_function (name, type)
5943      tree name, type;
5944 {
5945   return define_function
5946     (IDENTIFIER_POINTER (name), type, push_overloaded_decl_1,
5947      IDENTIFIER_POINTER (build_decl_overload (name, TYPE_ARG_TYPES (type),
5948                                               0)));
5949 }
5950
5951 /* Create the predefined scalar types of C,
5952    and some nodes representing standard constants (0, 1, (void *)0).
5953    Initialize the global binding level.
5954    Make definitions for built-in primitive functions.  */
5955
5956 void
5957 init_decl_processing ()
5958 {
5959   tree fields[20];
5960   int wchar_type_size;
5961   tree array_domain_type;
5962
5963   /* Have to make these distinct before we try using them.  */
5964   lang_name_cplusplus = get_identifier ("C++");
5965   lang_name_c = get_identifier ("C");
5966   lang_name_java = get_identifier ("Java");
5967
5968   /* Let the back-end now how to save and restore language-specific
5969      per-function globals.  */
5970   init_lang_status = &push_cp_function_context;
5971   free_lang_status = &pop_cp_function_context;
5972   mark_lang_status = &mark_cp_function_context;
5973
5974   cp_parse_init ();
5975   init_decl2 ();
5976   init_pt ();
5977
5978   /* Create the global variables.  */
5979   push_to_top_level ();
5980
5981   /* Enter the global namespace. */
5982   my_friendly_assert (global_namespace == NULL_TREE, 375);
5983   push_namespace (get_identifier ("::"));
5984   global_namespace = current_namespace;
5985   current_lang_name = NULL_TREE;
5986
5987   if (flag_strict_prototype == 2)
5988     flag_strict_prototype = pedantic;
5989   if (! flag_permissive && ! pedantic)
5990     flag_pedantic_errors = 1;
5991
5992   strict_prototypes_lang_c = flag_strict_prototype;
5993
5994   /* Initially, C.  */
5995   current_lang_name = lang_name_c;
5996
5997   current_function_decl = NULL_TREE;
5998   current_binding_level = NULL_BINDING_LEVEL;
5999   free_binding_level = NULL_BINDING_LEVEL;
6000
6001   /* Because most segmentation signals can be traced back into user
6002      code, catch them and at least give the user a chance of working
6003      around compiler bugs.  */
6004   signal (SIGSEGV, signal_catch);
6005
6006   /* We will also catch aborts in the back-end through signal_catch and
6007      give the user a chance to see where the error might be, and to defeat
6008      aborts in the back-end when there have been errors previously in their
6009      code.  */
6010 #ifdef SIGIOT
6011   signal (SIGIOT, signal_catch);
6012 #endif
6013 #ifdef SIGILL
6014   signal (SIGILL, signal_catch);
6015 #endif
6016 #ifdef SIGABRT
6017   signal (SIGABRT, signal_catch);
6018 #endif
6019 #ifdef SIGBUS
6020   signal (SIGBUS, signal_catch);
6021 #endif
6022
6023   build_common_tree_nodes (flag_signed_char);
6024
6025   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6026   TREE_TYPE (error_mark_list) = error_mark_node;
6027
6028   /* Make the binding_level structure for global names.  */
6029   pushlevel (0);
6030   global_binding_level = current_binding_level;
6031   /* The global level is the namespace level of ::.  */
6032   NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6033   declare_namespace_level ();
6034
6035   this_identifier = get_identifier (THIS_NAME);
6036   in_charge_identifier = get_identifier (IN_CHARGE_NAME);
6037   ctor_identifier = get_identifier (CTOR_NAME);
6038   dtor_identifier = get_identifier (DTOR_NAME);
6039   pfn_identifier = get_identifier (VTABLE_PFN_NAME);
6040   index_identifier = get_identifier (VTABLE_INDEX_NAME);
6041   delta_identifier = get_identifier (VTABLE_DELTA_NAME);
6042   delta2_identifier = get_identifier (VTABLE_DELTA2_NAME);
6043   pfn_or_delta2_identifier = get_identifier ("__pfn_or_delta2");
6044
6045   /* Define `int' and `char' first so that dbx will output them first.  */
6046   record_builtin_type (RID_INT, NULL_PTR, integer_type_node);
6047   record_builtin_type (RID_CHAR, "char", char_type_node);
6048
6049   /* `signed' is the same as `int' */
6050   record_builtin_type (RID_SIGNED, NULL_PTR, integer_type_node);
6051   record_builtin_type (RID_LONG, "long int", long_integer_type_node);
6052   record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
6053   record_builtin_type (RID_MAX, "long unsigned int", long_unsigned_type_node);
6054   record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
6055   record_builtin_type (RID_MAX, "long long int", long_long_integer_type_node);
6056   record_builtin_type (RID_MAX, "long long unsigned int",
6057                        long_long_unsigned_type_node);
6058   record_builtin_type (RID_MAX, "long long unsigned",
6059                        long_long_unsigned_type_node);
6060   record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
6061   record_builtin_type (RID_MAX, "short unsigned int", short_unsigned_type_node);
6062   record_builtin_type (RID_MAX, "unsigned short", short_unsigned_type_node);
6063
6064   ptrdiff_type_node
6065     = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE)));
6066
6067   /* Define both `signed char' and `unsigned char'.  */
6068   record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
6069   record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
6070
6071   /* `unsigned long' is the standard type for sizeof.
6072      Note that stddef.h uses `unsigned long',
6073      and this must agree, even if long and int are the same size.  */
6074   set_sizetype
6075     (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE))));
6076
6077   /* Create the widest literal types. */
6078   widest_integer_literal_type_node = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
6079   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6080                         widest_integer_literal_type_node));
6081
6082   widest_unsigned_literal_type_node = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
6083   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6084                         widest_unsigned_literal_type_node));
6085
6086   /* These are types that type_for_size and type_for_mode use.  */
6087   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
6088   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
6089   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
6090   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
6091 #if HOST_BITS_PER_WIDE_INT >= 64
6092   pushdecl (build_decl (TYPE_DECL, get_identifier ("__int128_t"), intTI_type_node));
6093 #endif
6094   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
6095   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
6096   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
6097   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
6098 #if HOST_BITS_PER_WIDE_INT >= 64
6099   pushdecl (build_decl (TYPE_DECL, get_identifier ("__uint128_t"), unsigned_intTI_type_node));
6100 #endif
6101
6102   build_common_tree_nodes_2 (flag_short_double);
6103
6104   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6105   java_short_type_node = record_builtin_java_type ("__java_short", 16);
6106   java_int_type_node = record_builtin_java_type ("__java_int", 32);
6107   java_long_type_node = record_builtin_java_type ("__java_long", 64);
6108   java_float_type_node = record_builtin_java_type ("__java_float", -32);
6109   java_double_type_node = record_builtin_java_type ("__java_double", -64);
6110   java_char_type_node = record_builtin_java_type ("__java_char", -16);
6111   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6112
6113   integer_two_node = build_int_2 (2, 0);
6114   TREE_TYPE (integer_two_node) = integer_type_node;
6115   integer_three_node = build_int_2 (3, 0);
6116   TREE_TYPE (integer_three_node) = integer_type_node;
6117
6118   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6119   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6120   TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6121   TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6122   TYPE_PRECISION (boolean_type_node) = 1;
6123   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6124   boolean_false_node = build_int_2 (0, 0);
6125   TREE_TYPE (boolean_false_node) = boolean_type_node;
6126   boolean_true_node = build_int_2 (1, 0);
6127   TREE_TYPE (boolean_true_node) = boolean_type_node;
6128
6129   signed_size_zero_node = build_int_2 (0, 0);  record_builtin_type (RID_FLOAT, NULL_PTR, float_type_node);
6130   record_builtin_type (RID_DOUBLE, NULL_PTR, double_type_node);
6131   record_builtin_type (RID_MAX, "long double", long_double_type_node);
6132
6133   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
6134                         complex_integer_type_node));
6135   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
6136                         complex_float_type_node));
6137   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),
6138                         complex_double_type_node));
6139   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
6140                         complex_long_double_type_node));
6141
6142   TREE_TYPE (signed_size_zero_node) = make_signed_type (TYPE_PRECISION (sizetype));
6143
6144   record_builtin_type (RID_VOID, NULL_PTR, void_type_node);
6145   void_list_node = build_tree_list (NULL_TREE, void_type_node);
6146   TREE_PARMLIST (void_list_node) = 1;
6147
6148   /* Used for expressions that do nothing, but are not errors.  */
6149   void_zero_node = build_int_2 (0, 0);
6150   TREE_TYPE (void_zero_node) = void_type_node;
6151
6152   string_type_node = build_pointer_type (char_type_node);
6153   const_string_type_node
6154     = build_pointer_type (build_qualified_type (char_type_node,
6155                                                 TYPE_QUAL_CONST));
6156   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6157 #if 0
6158   record_builtin_type (RID_MAX, NULL_PTR, string_type_node);
6159 #endif
6160
6161   /* Make a type to be the domain of a few array types
6162      whose domains don't really matter.
6163      200 is small enough that it always fits in size_t
6164      and large enough that it can hold most function names for the
6165      initializations of __FUNCTION__ and __PRETTY_FUNCTION__.  */
6166   array_domain_type = build_index_type (build_int_2 (200, 0));
6167
6168   /* Make a type for arrays of characters.
6169      With luck nothing will ever really depend on the length of this
6170      array type.  */
6171   char_array_type_node
6172     = build_array_type (char_type_node, array_domain_type);
6173   /* Likewise for arrays of ints.  */
6174   int_array_type_node
6175     = build_array_type (integer_type_node, array_domain_type);
6176
6177   /* This is just some anonymous class type.  Nobody should ever
6178      need to look inside this envelope.  */
6179   class_star_type_node = build_pointer_type (make_lang_type (RECORD_TYPE));
6180
6181   if (flag_huge_objects)
6182     delta_type_node = long_integer_type_node;
6183   else
6184     delta_type_node = short_integer_type_node;
6185
6186   default_function_type
6187     = build_function_type (integer_type_node, NULL_TREE);
6188
6189   ptr_type_node = build_pointer_type (void_type_node);
6190   const_ptr_type_node
6191     = build_pointer_type (build_qualified_type (void_type_node,
6192                                                 TYPE_QUAL_CONST));
6193   c_common_nodes_and_builtins (1, flag_no_builtin, flag_no_nonansi_builtin);
6194   lang_type_promotes_to = convert_type_from_ellipsis;
6195
6196   void_ftype_ptr
6197     = build_exception_variant (void_ftype_ptr, empty_except_spec);
6198
6199   /* C++ extensions */
6200
6201   unknown_type_node = make_node (UNKNOWN_TYPE);
6202   record_unknown_type (unknown_type_node, "unknown type");
6203
6204   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
6205   TREE_TYPE (unknown_type_node) = unknown_type_node;
6206
6207   TREE_TYPE (null_node) = type_for_size (POINTER_SIZE, 0);
6208
6209   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6210      result.  */
6211   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6212   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6213
6214   /* This is special for C++ so functions can be overloaded.  */
6215   wchar_type_node = get_identifier (flag_short_wchar
6216                                     ? "short unsigned int"
6217                                     : WCHAR_TYPE);
6218   wchar_type_node = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (wchar_type_node));
6219   wchar_type_size = TYPE_PRECISION (wchar_type_node);
6220   signed_wchar_type_node = make_signed_type (wchar_type_size);
6221   unsigned_wchar_type_node = make_unsigned_type (wchar_type_size);
6222   wchar_type_node
6223     = TREE_UNSIGNED (wchar_type_node)
6224       ? unsigned_wchar_type_node
6225       : signed_wchar_type_node;
6226   record_builtin_type (RID_WCHAR, "__wchar_t", wchar_type_node);
6227
6228   /* Artificial declaration of wchar_t -- can be bashed */
6229   wchar_decl_node = build_decl (TYPE_DECL, get_identifier ("wchar_t"),
6230                                 wchar_type_node);
6231   pushdecl (wchar_decl_node);
6232
6233   /* This is for wide string constants.  */
6234   wchar_array_type_node
6235     = build_array_type (wchar_type_node, array_domain_type);
6236
6237   if (flag_vtable_thunks)
6238     {
6239       /* Make sure we get a unique function type, so we can give
6240          its pointer type a name.  (This wins for gdb.) */
6241       tree vfunc_type = make_node (FUNCTION_TYPE);
6242       TREE_TYPE (vfunc_type) = integer_type_node;
6243       TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6244       layout_type (vfunc_type);
6245
6246       vtable_entry_type = build_pointer_type (vfunc_type);
6247     }
6248   else
6249     {
6250       vtable_entry_type = make_lang_type (RECORD_TYPE);
6251       fields[0] = build_lang_decl (FIELD_DECL, delta_identifier,
6252                                    delta_type_node);
6253       fields[1] = build_lang_decl (FIELD_DECL, index_identifier,
6254                                    delta_type_node);
6255       fields[2] = build_lang_decl (FIELD_DECL, pfn_identifier,
6256                                    ptr_type_node);
6257       finish_builtin_type (vtable_entry_type, VTBL_PTR_TYPE, fields, 2,
6258                            double_type_node);
6259
6260       /* Make this part of an invisible union.  */
6261       fields[3] = copy_node (fields[2]);
6262       TREE_TYPE (fields[3]) = delta_type_node;
6263       DECL_NAME (fields[3]) = delta2_identifier;
6264       DECL_MODE (fields[3]) = TYPE_MODE (delta_type_node);
6265       DECL_SIZE (fields[3]) = TYPE_SIZE (delta_type_node);
6266       TREE_UNSIGNED (fields[3]) = 0;
6267       TREE_CHAIN (fields[2]) = fields[3];
6268       vtable_entry_type = build_qualified_type (vtable_entry_type,
6269                                                 TYPE_QUAL_CONST);
6270     }
6271   record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6272
6273   vtbl_type_node
6274     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6275   layout_type (vtbl_type_node);
6276   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6277   record_builtin_type (RID_MAX, NULL_PTR, vtbl_type_node);
6278   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6279   layout_type (vtbl_ptr_type_node);
6280   record_builtin_type (RID_MAX, NULL_PTR, vtbl_ptr_type_node);
6281
6282   std_node = build_decl (NAMESPACE_DECL,
6283                          get_identifier (flag_honor_std ? "fake std":"std"),
6284                          void_type_node);
6285   pushdecl (std_node);
6286
6287   global_type_node = make_node (LANG_TYPE);
6288   record_unknown_type (global_type_node, "global type");
6289
6290   /* Now, C++.  */
6291   current_lang_name = lang_name_cplusplus;
6292
6293   {
6294     tree bad_alloc_type_node, newtype, deltype;
6295     if (flag_honor_std)
6296       push_namespace (get_identifier ("std"));
6297     bad_alloc_type_node = xref_tag
6298       (class_type_node, get_identifier ("bad_alloc"), 1);
6299     if (flag_honor_std)
6300       pop_namespace ();
6301     newtype = build_exception_variant
6302       (ptr_ftype_sizetype, add_exception_specifier (NULL_TREE, bad_alloc_type_node, -1));
6303     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6304     auto_function (ansi_opname[(int) NEW_EXPR], newtype);
6305     auto_function (ansi_opname[(int) VEC_NEW_EXPR], newtype);
6306     global_delete_fndecl = auto_function (ansi_opname[(int) DELETE_EXPR],
6307                                           deltype);
6308     auto_function (ansi_opname[(int) VEC_DELETE_EXPR], deltype);
6309   }
6310
6311   abort_fndecl
6312     = define_function ("__pure_virtual", void_ftype, 0, 0);
6313
6314   /* Perform other language dependent initializations.  */
6315   init_class_processing ();
6316   init_init_processing ();
6317   init_search_processing ();
6318   init_rtti_processing ();
6319
6320   if (flag_exceptions)
6321     init_exception_processing ();
6322   if (flag_no_inline)
6323     {
6324       flag_inline_functions = 0;
6325     }
6326
6327   if (! supports_one_only ())
6328     flag_weak = 0;
6329
6330   /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__.  */
6331   declare_function_name ();
6332
6333   /* Prepare to check format strings against argument lists.  */
6334   init_function_format_info ();
6335
6336   /* Show we use EH for cleanups.  */
6337   using_eh_for_cleanups ();
6338
6339   print_error_function = lang_print_error_function;
6340   lang_get_alias_set = &c_get_alias_set;
6341   valid_lang_attribute = cp_valid_lang_attribute;
6342
6343   /* Maintain consistency.  Perhaps we should just complain if they
6344      say -fwritable-strings?  */
6345   if (flag_writable_strings)
6346     flag_const_strings = 0;
6347
6348   /* Add GC roots for all of our global variables.  */
6349   ggc_add_tree_root (c_global_trees, sizeof c_global_trees / sizeof(tree));
6350   ggc_add_tree_root (cp_global_trees, sizeof cp_global_trees / sizeof(tree));
6351   ggc_add_tree_root (&integer_three_node, 1);
6352   ggc_add_tree_root (&integer_two_node, 1);
6353   ggc_add_tree_root (&signed_size_zero_node, 1);
6354   ggc_add_tree_root (&size_one_node, 1);
6355   ggc_add_tree_root (&size_zero_node, 1);
6356   ggc_add_root (&global_binding_level, 1, sizeof global_binding_level,
6357                 mark_binding_level);
6358   ggc_add_root (&scope_chain, 1, sizeof scope_chain, &mark_saved_scope);
6359   ggc_add_tree_root (&static_ctors, 1);
6360   ggc_add_tree_root (&static_dtors, 1);
6361   ggc_add_tree_root (&lastiddecl, 1);
6362
6363   ggc_add_tree_root (&enum_next_value, 1);
6364   ggc_add_tree_root (&last_function_parm_tags, 1);
6365   ggc_add_tree_root (&current_function_return_value, 1);
6366   ggc_add_tree_root (&current_function_parms, 1);
6367   ggc_add_tree_root (&current_function_parm_tags, 1);
6368   ggc_add_tree_root (&last_function_parms, 1);
6369   ggc_add_tree_root (&error_mark_list, 1);
6370
6371   ggc_add_tree_root (&global_namespace, 1);
6372   ggc_add_tree_root (&global_type_node, 1);
6373   ggc_add_tree_root (&anonymous_namespace_name, 1);
6374
6375   ggc_add_tree_root (&got_object, 1);
6376   ggc_add_tree_root (&got_scope, 1);
6377
6378   ggc_add_tree_root (&current_lang_name, 1);
6379   ggc_add_tree_root (&static_aggregates, 1);
6380 }
6381
6382 /* Function to print any language-specific context for an error message.  */
6383
6384 static void
6385 lang_print_error_function (file)
6386      const char *file;
6387 {
6388   default_print_error_function (file);
6389   maybe_print_template_context ();
6390 }
6391
6392 /* Make a definition for a builtin function named NAME and whose data type
6393    is TYPE.  TYPE should be a function type with argument types.
6394
6395    If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6396    the name to be called if we can't opencode the function.  */
6397
6398 tree
6399 define_function (name, type, pfn, library_name)
6400      const char *name;
6401      tree type;
6402      void (*pfn) PROTO((tree));
6403      const char *library_name;
6404 {
6405   tree decl = build_lang_decl (FUNCTION_DECL, get_identifier (name), type);
6406   DECL_EXTERNAL (decl) = 1;
6407   TREE_PUBLIC (decl) = 1;
6408   DECL_ARTIFICIAL (decl) = 1;
6409
6410   my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 392);
6411   DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
6412
6413   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6414      we cannot change DECL_ASSEMBLER_NAME until we have installed this
6415      function in the namespace.  */
6416   if (pfn) (*pfn) (decl);
6417   if (library_name)
6418     DECL_ASSEMBLER_NAME (decl) = get_identifier (library_name);
6419   make_function_rtl (decl);
6420   return decl;
6421 }
6422
6423
6424 /* Wrapper around define_function, for the benefit of
6425    c_common_nodes_and_builtins.
6426    FUNCTION_CODE tells later passes how to compile calls to this function.
6427    See tree.h for its possible values.  */
6428
6429 tree
6430 builtin_function (name, type, code, class, libname)
6431      const char *name;
6432      tree type;
6433      int code;
6434      enum built_in_class class;
6435      const char *libname;
6436 {
6437   tree decl = define_function (name, type, (void (*) PROTO((tree)))pushdecl,
6438                                libname);
6439   DECL_BUILT_IN_CLASS (decl) = class;
6440   DECL_FUNCTION_CODE (decl) = code;
6441   return decl;
6442 }
6443 \f
6444 /* When we call finish_struct for an anonymous union, we create
6445    default copy constructors and such.  But, an anonymous union
6446    shouldn't have such things; this function undoes the damage to the
6447    anonymous union type T.
6448
6449    (The reason that we create the synthesized methods is that we don't
6450    distinguish `union { int i; }' from `typedef union { int i; } U'.
6451    The first is an anonymous union; the second is just an ordinary
6452    union type.)  */
6453
6454 void
6455 fixup_anonymous_aggr (t)
6456      tree t;
6457 {
6458   tree *q;
6459
6460   /* Wipe out memory of synthesized methods */
6461   TYPE_HAS_CONSTRUCTOR (t) = 0;
6462   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6463   TYPE_HAS_INIT_REF (t) = 0;
6464   TYPE_HAS_CONST_INIT_REF (t) = 0;
6465   TYPE_HAS_ASSIGN_REF (t) = 0;
6466   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6467
6468   /* Splice the implicitly generated functions out of the TYPE_METHODS
6469      list.  */
6470   q = &TYPE_METHODS (t);
6471   while (*q)
6472     {
6473       if (DECL_ARTIFICIAL (*q))
6474         *q = TREE_CHAIN (*q);
6475       else
6476         q = &TREE_CHAIN (*q);
6477     }
6478
6479   /* ANSI C++ June 5 1992 WP 9.5.3.  Anonymous unions may not have
6480      function members.  */
6481   if (TYPE_METHODS (t))
6482     error ("an anonymous union cannot have function members");
6483 }
6484
6485 /* Make sure that a declaration with no declarator is well-formed, i.e.
6486    just defines a tagged type or anonymous union.
6487
6488    Returns the type defined, if any.  */
6489
6490 tree
6491 check_tag_decl (declspecs)
6492      tree declspecs;
6493 {
6494   int found_type = 0;
6495   tree ob_modifier = NULL_TREE;
6496   register tree link;
6497   register tree t = NULL_TREE;
6498
6499   for (link = declspecs; link; link = TREE_CHAIN (link))
6500     {
6501       register tree value = TREE_VALUE (link);
6502
6503       if (TYPE_P (value))
6504         {
6505           ++found_type;
6506
6507           if (IS_AGGR_TYPE (value) || TREE_CODE (value) == ENUMERAL_TYPE)
6508             {
6509               my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
6510               t = value;
6511             }
6512         }
6513       else if (value == ridpointers[(int) RID_FRIEND])
6514         {
6515           if (current_class_type == NULL_TREE
6516               || current_scope () != current_class_type)
6517             ob_modifier = value;
6518         }
6519       else if (value == ridpointers[(int) RID_STATIC]
6520                || value == ridpointers[(int) RID_EXTERN]
6521                || value == ridpointers[(int) RID_AUTO]
6522                || value == ridpointers[(int) RID_REGISTER]
6523                || value == ridpointers[(int) RID_INLINE]
6524                || value == ridpointers[(int) RID_VIRTUAL]
6525                || value == ridpointers[(int) RID_CONST]
6526                || value == ridpointers[(int) RID_VOLATILE]
6527                || value == ridpointers[(int) RID_EXPLICIT])
6528         ob_modifier = value;
6529     }
6530
6531   if (found_type > 1)
6532     error ("multiple types in one declaration");
6533
6534   /* Inside a class, we might be in a friend or access declaration.
6535      Until we have a good way of detecting the latter, don't warn.  */
6536   if (t == NULL_TREE && ! current_class_type)
6537     pedwarn ("declaration does not declare anything");
6538
6539   /* Check for an anonymous union.  We're careful
6540      accessing TYPE_IDENTIFIER because some built-in types, like
6541      pointer-to-member types, do not have TYPE_NAME.  */
6542   else if (t && IS_AGGR_TYPE_CODE (TREE_CODE (t))
6543            && TYPE_NAME (t)
6544            && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
6545     {
6546       /* Anonymous unions are objects, so they can have specifiers.  */;
6547       SET_ANON_AGGR_TYPE_P (t);
6548
6549       if (TREE_CODE (t) != UNION_TYPE && pedantic && ! in_system_header)
6550         pedwarn ("ISO C++ prohibits anonymous structs");
6551     }
6552
6553   else if (ob_modifier)
6554     {
6555       if (ob_modifier == ridpointers[(int) RID_INLINE]
6556           || ob_modifier == ridpointers[(int) RID_VIRTUAL])
6557         cp_error ("`%D' can only be specified for functions", ob_modifier);
6558       else if (ob_modifier == ridpointers[(int) RID_FRIEND])
6559         cp_error ("`%D' can only be specified inside a class", ob_modifier);
6560       else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
6561         cp_error ("`%D' can only be specified for constructors",
6562                   ob_modifier);
6563       else
6564         cp_error ("`%D' can only be specified for objects and functions",
6565                   ob_modifier);
6566     }
6567
6568   return t;
6569 }
6570
6571 /* Called when a declaration is seen that contains no names to declare.
6572    If its type is a reference to a structure, union or enum inherited
6573    from a containing scope, shadow that tag name for the current scope
6574    with a forward reference.
6575    If its type defines a new named structure or union
6576    or defines an enum, it is valid but we need not do anything here.
6577    Otherwise, it is an error.
6578
6579    C++: may have to grok the declspecs to learn about static,
6580    complain for anonymous unions.  */
6581
6582 void
6583 shadow_tag (declspecs)
6584      tree declspecs;
6585 {
6586   tree t = check_tag_decl (declspecs);
6587
6588   if (t)
6589     maybe_process_partial_specialization (t);
6590
6591   /* This is where the variables in an anonymous union are
6592      declared.  An anonymous union declaration looks like:
6593      union { ... } ;
6594      because there is no declarator after the union, the parser
6595      sends that declaration here.  */
6596   if (t && ANON_AGGR_TYPE_P (t))
6597     {
6598       fixup_anonymous_aggr (t);
6599
6600       if (TYPE_FIELDS (t))
6601         {
6602           tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
6603                                       NULL_TREE);
6604           finish_anon_union (decl);
6605         }
6606     }
6607 }
6608 \f
6609 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
6610
6611 tree
6612 groktypename (typename)
6613      tree typename;
6614 {
6615   if (TREE_CODE (typename) != TREE_LIST)
6616     return typename;
6617   return grokdeclarator (TREE_VALUE (typename),
6618                          TREE_PURPOSE (typename),
6619                          TYPENAME, 0, NULL_TREE);
6620 }
6621
6622 /* Decode a declarator in an ordinary declaration or data definition.
6623    This is called as soon as the type information and variable name
6624    have been parsed, before parsing the initializer if any.
6625    Here we create the ..._DECL node, fill in its type,
6626    and put it on the list of decls for the current context.
6627    The ..._DECL node is returned as the value.
6628
6629    Exception: for arrays where the length is not specified,
6630    the type is left null, to be filled in by `cp_finish_decl'.
6631
6632    Function definitions do not come here; they go to start_function
6633    instead.  However, external and forward declarations of functions
6634    do go through here.  Structure field declarations are done by
6635    grokfield and not through here.  */
6636
6637 /* Set this to zero to debug not using the temporary obstack
6638    to parse initializers.  */
6639 int debug_temp_inits = 1;
6640
6641 tree
6642 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
6643      tree declarator, declspecs;
6644      int initialized;
6645      tree attributes, prefix_attributes;
6646 {
6647   register tree decl;
6648   register tree type, tem;
6649   tree context;
6650   extern int have_extern_spec;
6651   extern int used_extern_spec;
6652   tree attrlist;
6653
6654 #if 0
6655   /* See code below that used this.  */
6656   int init_written = initialized;
6657 #endif
6658
6659   /* This should only be done once on the top most decl.  */
6660   if (have_extern_spec && !used_extern_spec)
6661     {
6662       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"),
6663                                   declspecs);
6664       used_extern_spec = 1;
6665     }
6666
6667   if (attributes || prefix_attributes)
6668     attrlist = build_scratch_list (attributes, prefix_attributes);
6669   else
6670     attrlist = NULL_TREE;
6671
6672   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
6673                          attrlist);
6674
6675   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
6676     return NULL_TREE;
6677
6678   type = TREE_TYPE (decl);
6679
6680   if (type == error_mark_node)
6681     return NULL_TREE;
6682
6683   context
6684     = (TREE_CODE (decl) == FUNCTION_DECL && DECL_VIRTUAL_P (decl))
6685       ? DECL_CLASS_CONTEXT (decl)
6686       : DECL_CONTEXT (decl);
6687
6688   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
6689       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
6690     {
6691       /* When parsing the initializer, lookup should use the object's
6692          namespace. */
6693       push_decl_namespace (context);
6694     }
6695
6696   /* We are only interested in class contexts, later. */
6697   if (context && TREE_CODE (context) == NAMESPACE_DECL)
6698     context = NULL_TREE;
6699
6700   if (initialized)
6701     /* Is it valid for this decl to have an initializer at all?
6702        If not, set INITIALIZED to zero, which will indirectly
6703        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
6704     switch (TREE_CODE (decl))
6705       {
6706       case TYPE_DECL:
6707         /* typedef foo = bar  means give foo the same type as bar.
6708            We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
6709            Any other case of an initialization in a TYPE_DECL is an error.  */
6710         if (pedantic || list_length (declspecs) > 1)
6711           {
6712             cp_error ("typedef `%D' is initialized", decl);
6713             initialized = 0;
6714           }
6715         break;
6716
6717       case FUNCTION_DECL:
6718         cp_error ("function `%#D' is initialized like a variable", decl);
6719         initialized = 0;
6720         break;
6721
6722       default:
6723         break;
6724       }
6725
6726   if (initialized)
6727     {
6728       if (! toplevel_bindings_p ()
6729           && DECL_EXTERNAL (decl))
6730         cp_warning ("declaration of `%#D' has `extern' and is initialized",
6731                     decl);
6732       DECL_EXTERNAL (decl) = 0;
6733       if (toplevel_bindings_p ())
6734         TREE_STATIC (decl) = 1;
6735
6736       /* Tell `pushdecl' this is an initialized decl
6737          even though we don't yet have the initializer expression.
6738          Also tell `cp_finish_decl' it may store the real initializer.  */
6739       DECL_INITIAL (decl) = error_mark_node;
6740     }
6741
6742 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
6743   SET_DEFAULT_DECL_ATTRIBUTES (decl, attributes);
6744 #endif
6745
6746   /* Set attributes here so if duplicate decl, will have proper attributes.  */
6747   cplus_decl_attributes (decl, attributes, prefix_attributes);
6748
6749   if (context && TYPE_SIZE (complete_type (context)) != NULL_TREE)
6750     {
6751       push_nested_class (context, 2);
6752
6753       if (TREE_CODE (decl) == VAR_DECL)
6754         {
6755           tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
6756           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
6757             cp_error ("`%#D' is not a static member of `%#T'", decl, context);
6758           else
6759             {
6760               if (DECL_CONTEXT (field) != context)
6761                 {
6762                   cp_pedwarn ("ANSI C++ does not permit `%T::%D' to be defined as `%T::%D'",
6763                               DECL_CONTEXT (field), DECL_NAME (decl),
6764                               context, DECL_NAME (decl));
6765                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
6766                 }
6767               /* Static data member are tricky; an in-class initialization
6768                  still doesn't provide a definition, so the in-class
6769                  declaration will have DECL_EXTERNAL set, but will have an
6770                  initialization.  Thus, duplicate_decls won't warn
6771                  about this situation, and so we check here.  */
6772               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
6773                 cp_error ("duplicate initialization of %D", decl);
6774               if (duplicate_decls (decl, field))
6775                 decl = field;
6776             }
6777         }
6778       else
6779         {
6780           tree field = check_classfn (context, decl);
6781           if (field && duplicate_decls (decl, field))
6782             decl = field;
6783         }
6784
6785       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
6786       DECL_IN_AGGR_P (decl) = 0;
6787       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
6788           || CLASSTYPE_USE_TEMPLATE (context))
6789         {
6790           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
6791           /* [temp.expl.spec] An explicit specialization of a static data
6792              member of a template is a definition if the declaration
6793              includes an initializer; otherwise, it is a declaration.
6794
6795              We check for processing_specialization so this only applies
6796              to the new specialization syntax.  */
6797           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
6798             DECL_EXTERNAL (decl) = 1;
6799         }
6800
6801       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
6802         cp_pedwarn ("declaration of `%#D' outside of class is not definition",
6803                     decl);
6804     }
6805
6806   /* Enter this declaration into the symbol table.  */
6807   tem = maybe_push_decl (decl);
6808
6809   if (processing_template_decl)
6810     {
6811       if (at_function_scope_p ())
6812         push_permanent_obstack ();
6813       tem = push_template_decl (tem);
6814       if (at_function_scope_p ())
6815         pop_obstacks ();
6816     }
6817
6818
6819 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
6820   /* Tell the back-end to use or not use .common as appropriate.  If we say
6821      -fconserve-space, we want this to save .data space, at the expense of
6822      wrong semantics.  If we say -fno-conserve-space, we want this to
6823      produce errors about redefs; to do this we force variables into the
6824      data segment.  */
6825   DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
6826 #endif
6827
6828   if (! processing_template_decl)
6829     start_decl_1 (tem);
6830
6831   /* Corresponding pop_obstacks is done in `cp_finish_decl'.  */
6832   push_obstacks_nochange ();
6833
6834   return tem;
6835 }
6836
6837 void
6838 start_decl_1 (decl)
6839      tree decl;
6840 {
6841   tree type = TREE_TYPE (decl);
6842   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
6843
6844   if (type == error_mark_node)
6845     return;
6846
6847   /* If this type of object needs a cleanup, but we're not allowed to
6848      add any more objects with cleanups to the current scope, create a
6849      new binding level.  */
6850   if (TYPE_NEEDS_DESTRUCTOR (type)
6851       && current_binding_level->more_cleanups_ok == 0)
6852     {
6853       keep_next_level (2);
6854       pushlevel (1);
6855       clear_last_expr ();
6856       add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
6857     }
6858
6859   if (initialized)
6860     /* Is it valid for this decl to have an initializer at all?
6861        If not, set INITIALIZED to zero, which will indirectly
6862        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
6863     {
6864       /* Don't allow initializations for incomplete types except for
6865          arrays which might be completed by the initialization.  */
6866       if (TYPE_SIZE (complete_type (type)) != NULL_TREE)
6867         ;                       /* A complete type is ok.  */
6868       else if (TREE_CODE (type) != ARRAY_TYPE)
6869         {
6870           cp_error ("variable `%#D' has initializer but incomplete type",
6871                     decl);
6872           initialized = 0;
6873           type = TREE_TYPE (decl) = error_mark_node;
6874         }
6875       else if (TYPE_SIZE (complete_type (TREE_TYPE (type))) == NULL_TREE)
6876         {
6877           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
6878             cp_error ("elements of array `%#D' have incomplete type", decl);
6879           /* else we already gave an error in start_decl.  */
6880           initialized = 0;
6881         }
6882     }
6883
6884   if (!initialized
6885       && TREE_CODE (decl) != TYPE_DECL
6886       && TREE_CODE (decl) != TEMPLATE_DECL
6887       && IS_AGGR_TYPE (type) && ! DECL_EXTERNAL (decl))
6888     {
6889       if ((! processing_template_decl || ! uses_template_parms (type))
6890           && TYPE_SIZE (complete_type (type)) == NULL_TREE)
6891         {
6892           cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
6893                  decl);
6894           /* Change the type so that assemble_variable will give
6895              DECL an rtl we can live with: (mem (const_int 0)).  */
6896           type = TREE_TYPE (decl) = error_mark_node;
6897         }
6898       else
6899         {
6900           /* If any base type in the hierarchy of TYPE needs a constructor,
6901              then we set initialized to 1.  This way any nodes which are
6902              created for the purposes of initializing this aggregate
6903              will live as long as it does.  This is necessary for global
6904              aggregates which do not have their initializers processed until
6905              the end of the file.  */
6906           initialized = TYPE_NEEDS_CONSTRUCTING (type);
6907         }
6908     }
6909
6910   if (! initialized)
6911     DECL_INITIAL (decl) = NULL_TREE;
6912 }
6913
6914 /* Handle initialization of references.
6915    These three arguments are from `cp_finish_decl', and have the
6916    same meaning here that they do there.
6917
6918    Quotes on semantics can be found in ARM 8.4.3.  */
6919
6920 static void
6921 grok_reference_init (decl, type, init)
6922      tree decl, type, init;
6923 {
6924   tree tmp;
6925
6926   if (init == NULL_TREE)
6927     {
6928       if ((DECL_LANG_SPECIFIC (decl) == 0
6929            || DECL_IN_AGGR_P (decl) == 0)
6930           && ! DECL_THIS_EXTERN (decl))
6931         cp_error ("`%D' declared as reference but not initialized", decl);
6932       return;
6933     }
6934
6935   if (init == error_mark_node)
6936     return;
6937
6938   if (TREE_CODE (init) == CONSTRUCTOR)
6939     {
6940       cp_error ("ANSI C++ forbids use of initializer list to initialize reference `%D'", decl);
6941       return;
6942     }
6943
6944   if (TREE_CODE (init) == TREE_LIST)
6945     init = build_compound_expr (init);
6946
6947   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
6948     init = convert_from_reference (init);
6949
6950   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
6951       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
6952     {
6953       /* Note: default conversion is only called in very special cases.  */
6954       init = default_conversion (init);
6955     }
6956
6957   /* Convert INIT to the reference type TYPE.  This may involve the
6958      creation of a temporary, whose lifetime must be the same as that
6959      of the reference.  If so, a DECL_STMT for the temporary will be
6960      added just after the DECL_STMT for DECL.  That's why we don't set
6961      DECL_INITIAL for local references (instead assigning to them
6962      explicitly); we need to allow the temporary to be initialized
6963      first.  */
6964   tmp = convert_to_reference
6965     (type, init, CONV_IMPLICIT,
6966      LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND, decl);
6967
6968   if (tmp == error_mark_node)
6969     return;
6970   else if (tmp != NULL_TREE)
6971     {
6972       init = tmp;
6973       tmp = save_expr (tmp);
6974       if (building_stmt_tree ())
6975         {
6976           /* Initialize the declaration.  */
6977           tmp = build (INIT_EXPR, TREE_TYPE (decl), decl, tmp);
6978           finish_expr_stmt (tmp);
6979         }
6980       else
6981         DECL_INITIAL (decl) = tmp;
6982     }
6983   else
6984     {
6985       cp_error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
6986       return;
6987     }
6988
6989   if (TREE_STATIC (decl) && ! TREE_CONSTANT (DECL_INITIAL (decl)))
6990     {
6991       expand_static_init (decl, DECL_INITIAL (decl));
6992       DECL_INITIAL (decl) = NULL_TREE;
6993     }
6994   return;
6995 }
6996
6997 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
6998    mucking with forces it does not comprehend (i.e. initialization with a
6999    constructor).  If we are at global scope and won't go into COMMON, fill
7000    it in with a dummy CONSTRUCTOR to force the variable into .data;
7001    otherwise we can use error_mark_node.  */
7002
7003 static tree
7004 obscure_complex_init (decl, init)
7005      tree decl, init;
7006 {
7007   if (! flag_no_inline && TREE_STATIC (decl))
7008     {
7009       if (extract_init (decl, init))
7010         return NULL_TREE;
7011     }
7012
7013 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7014   if (toplevel_bindings_p () && ! DECL_COMMON (decl))
7015     DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
7016                                  NULL_TREE);
7017   else
7018 #endif
7019     DECL_INITIAL (decl) = error_mark_node;
7020
7021   return init;
7022 }
7023
7024 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7025    array until we finish parsing the initializer.  If that's the
7026    situation we're in, update DECL accordingly.  */
7027
7028 static void
7029 maybe_deduce_size_from_array_init (decl, init)
7030      tree decl;
7031      tree init;
7032 {
7033   tree type = TREE_TYPE (decl);
7034
7035   if (TREE_CODE (type) == ARRAY_TYPE
7036       && TYPE_DOMAIN (type) == NULL_TREE
7037       && TREE_CODE (decl) != TYPE_DECL)
7038     {
7039       int do_default
7040         = (TREE_STATIC (decl)
7041            /* Even if pedantic, an external linkage array
7042               may have incomplete type at first.  */
7043            ? pedantic && ! DECL_EXTERNAL (decl)
7044            : !DECL_EXTERNAL (decl));
7045       tree initializer = init ? init : DECL_INITIAL (decl);
7046       int failure = complete_array_type (type, initializer, do_default);
7047
7048       if (failure == 1)
7049         cp_error ("initializer fails to determine size of `%D'", decl);
7050
7051       if (failure == 2)
7052         {
7053           if (do_default)
7054             cp_error ("array size missing in `%D'", decl);
7055           /* If a `static' var's size isn't known, make it extern as
7056              well as static, so it does not get allocated.  If it's not
7057              `static', then don't mark it extern; finish_incomplete_decl
7058              will give it a default size and it will get allocated.  */
7059           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7060             DECL_EXTERNAL (decl) = 1;
7061         }
7062
7063       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7064           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7065                               integer_zero_node))
7066         cp_error ("zero-size array `%D'", decl);
7067
7068       layout_decl (decl, 0);
7069     }
7070 }
7071
7072 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7073    any appropriate error messages regarding the layout.  */
7074
7075 static void
7076 layout_var_decl (decl)
7077      tree decl;
7078 {
7079   tree type = TREE_TYPE (decl);
7080   tree ttype = target_type (type);
7081
7082   /* If we haven't already layed out this declaration, do so now.
7083      Note that we must not call complete type for an external object
7084      because it's type might involve templates that we are not
7085      supposed to isntantiate yet.  (And it's perfectly legal to say
7086      `extern X x' for some incomplete type `X'.)  */
7087   if (!DECL_EXTERNAL (decl))
7088     complete_type (type);
7089   if (!DECL_SIZE (decl)&& TYPE_SIZE (type))
7090     layout_decl (decl, 0);
7091
7092   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7093     {
7094       /* An automatic variable with an incomplete type: that is an error.
7095          Don't talk about array types here, since we took care of that
7096          message in grokdeclarator.  */
7097       cp_error ("storage size of `%D' isn't known", decl);
7098       TREE_TYPE (decl) = error_mark_node;
7099     }
7100   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7101     /* Let debugger know it should output info for this type.  */
7102     note_debug_info_needed (ttype);
7103
7104   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7105     note_debug_info_needed (DECL_CONTEXT (decl));
7106
7107   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7108       && DECL_SIZE (decl) != NULL_TREE
7109       && ! TREE_CONSTANT (DECL_SIZE (decl)))
7110     {
7111       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7112         constant_expression_warning (DECL_SIZE (decl));
7113       else
7114         cp_error ("storage size of `%D' isn't constant", decl);
7115     }
7116 }
7117
7118 /* If a local static variable is declared in an inline function, or if
7119    we have a weak definition, we must endeavor to create only one
7120    instance of the variable at link-time.  */
7121
7122 static void
7123 maybe_commonize_var (decl)
7124      tree decl;
7125 {
7126   /* Static data in a function with comdat linkage also has comdat
7127      linkage.  */
7128   if (TREE_STATIC (decl)
7129       /* Don't mess with __FUNCTION__.  */
7130       && ! TREE_ASM_WRITTEN (decl)
7131       && current_function_decl
7132       && DECL_CONTEXT (decl) == current_function_decl
7133       && (DECL_THIS_INLINE (current_function_decl)
7134           || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7135       && TREE_PUBLIC (current_function_decl))
7136     {
7137       /* Rather than try to get this right with inlining, we suppress
7138          inlining of such functions.  */
7139       current_function_cannot_inline
7140         = "function with static variable cannot be inline";
7141
7142       /* If flag_weak, we don't need to mess with this, as we can just
7143          make the function weak, and let it refer to its unique local
7144          copy.  This works because we don't allow the function to be
7145          inlined.  */
7146       if (! flag_weak)
7147         {
7148           if (DECL_INTERFACE_KNOWN (current_function_decl))
7149             {
7150               TREE_PUBLIC (decl) = 1;
7151               DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7152             }
7153           else if (DECL_INITIAL (decl) == NULL_TREE
7154                    || DECL_INITIAL (decl) == error_mark_node)
7155             {
7156               TREE_PUBLIC (decl) = 1;
7157               DECL_COMMON (decl) = 1;
7158             }
7159           /* else we lose. We can only do this if we can use common,
7160              which we can't if it has been initialized.  */
7161
7162           if (TREE_PUBLIC (decl))
7163             DECL_ASSEMBLER_NAME (decl)
7164               = build_static_name (current_function_decl, DECL_NAME (decl));
7165           else if (! DECL_ARTIFICIAL (decl))
7166             {
7167               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7168               cp_warning_at ("  you can work around this by removing the initializer", decl);
7169             }
7170         }
7171     }
7172   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7173     /* Set it up again; we might have set DECL_INITIAL since the last
7174        time.  */
7175     comdat_linkage (decl);
7176 }
7177
7178 /* Issue an error message if DECL is an uninitialized const variable.  */
7179
7180 static void
7181 check_for_uninitialized_const_var (decl)
7182      tree decl;
7183 {
7184   tree type = TREE_TYPE (decl);
7185
7186   /* ``Unless explicitly declared extern, a const object does not have
7187      external linkage and must be initialized. ($8.4; $12.1)'' ARM
7188      7.1.6 */
7189   if (TREE_CODE (decl) == VAR_DECL
7190       && TREE_CODE (type) != REFERENCE_TYPE
7191       && CP_TYPE_CONST_P (type)
7192       && !TYPE_NEEDS_CONSTRUCTING (type)
7193       && !DECL_INITIAL (decl))
7194     cp_error ("uninitialized const `%D'", decl);
7195 }
7196
7197 /* Verify INIT (the initializer for DECL), and record the
7198    initialization in DECL_INITIAL, if appropriate.  Returns a new
7199    value for INIT.  */
7200
7201 static tree
7202 check_initializer (decl, init)
7203      tree decl;
7204      tree init;
7205 {
7206   tree type;
7207
7208   if (TREE_CODE (decl) == FIELD_DECL)
7209     return init;
7210
7211   type = TREE_TYPE (decl);
7212
7213   /* If `start_decl' didn't like having an initialization, ignore it now.  */
7214   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7215     init = NULL_TREE;
7216
7217   /* Check the initializer.  */
7218   if (init)
7219     {
7220       /* Things that are going to be initialized need to have complete
7221          type.  */
7222       TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7223
7224       if (type == error_mark_node)
7225         /* We will have already complained.  */
7226         init = NULL_TREE;
7227       else if (TYPE_SIZE (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
7228         {
7229           cp_error ("variable-sized object `%D' may not be initialized", decl);
7230           init = NULL_TREE;
7231         }
7232       else if (TREE_CODE (type) == ARRAY_TYPE
7233                && !TYPE_SIZE (TREE_TYPE (type)))
7234         {
7235           cp_error ("elements of array `%#D' have incomplete type", decl);
7236           init = NULL_TREE;
7237         }
7238       else if (!TYPE_SIZE (type))
7239         {
7240           cp_error ("`%D' has incomplete type", decl);
7241           TREE_TYPE (decl) = error_mark_node;
7242           init = NULL_TREE;
7243         }
7244     }
7245
7246   if (TREE_CODE (decl) == CONST_DECL)
7247     {
7248       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7249
7250       DECL_INITIAL (decl) = init;
7251
7252       /* This will keep us from needing to worry about our obstacks.  */
7253       my_friendly_assert (init != NULL_TREE, 149);
7254       init = NULL_TREE;
7255     }
7256   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7257     {
7258       if (TREE_STATIC (decl))
7259         make_decl_rtl (decl, NULL_PTR, toplevel_bindings_p ());
7260       grok_reference_init (decl, type, init);
7261       init = NULL_TREE;
7262     }
7263   else if (init)
7264     {
7265       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7266         {
7267           if (TREE_CODE (type) == ARRAY_TYPE)
7268             init = digest_init (type, init, (tree *) 0);
7269           else if (TREE_CODE (init) == CONSTRUCTOR
7270                    && TREE_HAS_CONSTRUCTOR (init))
7271             {
7272               if (TYPE_NON_AGGREGATE_CLASS (type))
7273                 {
7274                   cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7275                             decl);
7276                   init = error_mark_node;
7277                 }
7278               else
7279                 goto dont_use_constructor;
7280             }
7281         }
7282       else
7283         {
7284         dont_use_constructor:
7285           if (TREE_CODE (init) != TREE_VEC)
7286             init = store_init_value (decl, init);
7287         }
7288
7289       if (init)
7290         /* We must hide the initializer so that expand_decl
7291            won't try to do something it does not understand.  */
7292         init = obscure_complex_init (decl, init);
7293     }
7294   else if (DECL_EXTERNAL (decl))
7295     ;
7296   else if (TREE_CODE_CLASS (TREE_CODE (type)) == 't'
7297            && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
7298     {
7299       tree core_type = strip_array_types (type);
7300
7301       if (! TYPE_NEEDS_CONSTRUCTING (core_type))
7302         {
7303           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
7304             cp_error ("structure `%D' with uninitialized const members", decl);
7305           if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
7306             cp_error ("structure `%D' with uninitialized reference members",
7307                       decl);
7308         }
7309
7310       check_for_uninitialized_const_var (decl);
7311
7312       if (TYPE_SIZE (type) != NULL_TREE
7313           && TYPE_NEEDS_CONSTRUCTING (type))
7314         init = obscure_complex_init (decl, NULL_TREE);
7315
7316     }
7317   else
7318     check_for_uninitialized_const_var (decl);
7319
7320   return init;
7321 }
7322
7323 /* If DECL is not a local variable, give it RTL.  */
7324
7325 static void
7326 make_rtl_for_nonlocal_decl (decl, init, asmspec)
7327      tree decl;
7328      tree init;
7329      const char *asmspec;
7330 {
7331   int toplev;
7332   tree type;
7333
7334   type = TREE_TYPE (decl);
7335   toplev = toplevel_bindings_p ();
7336
7337   /* Handle non-variables up front.  */
7338   if (TREE_CODE (decl) != VAR_DECL)
7339     {
7340       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7341       return;
7342     }
7343
7344   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
7345   if (asmspec)
7346     DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
7347
7348   if (DECL_VIRTUAL_P (decl))
7349     make_decl_rtl (decl, NULL_PTR, toplev);
7350   else if (TREE_READONLY (decl)
7351            && DECL_INITIAL (decl) != NULL_TREE
7352            && DECL_INITIAL (decl) != error_mark_node
7353            && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl)))
7354     {
7355       DECL_INITIAL (decl) = save_expr (DECL_INITIAL (decl));
7356
7357       if (toplev && ! TREE_PUBLIC (decl))
7358         {
7359           /* If this is a static const, change its apparent linkage
7360              if it belongs to a #pragma interface.  */
7361           if (!interface_unknown)
7362             {
7363               TREE_PUBLIC (decl) = 1;
7364               DECL_EXTERNAL (decl) = interface_only;
7365             }
7366           make_decl_rtl (decl, asmspec, toplev);
7367         }
7368       else if (toplev)
7369         rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7370     }
7371   else if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
7372     {
7373       my_friendly_assert (TREE_STATIC (decl), 19990828);
7374
7375       if (init == NULL_TREE
7376 #ifdef DEFAULT_STATIC_DEFS
7377           /* If this code is dead, then users must
7378              explicitly declare static member variables
7379              outside the class def'n as well.  */
7380           && TYPE_NEEDS_CONSTRUCTING (type)
7381 #endif
7382           )
7383         {
7384           DECL_EXTERNAL (decl) = 1;
7385           make_decl_rtl (decl, asmspec, 1);
7386         }
7387       else
7388         rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7389     }
7390   else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == NAMESPACE_DECL
7391            || (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl)))
7392     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7393 }
7394
7395 /* Create RTL for the local static variable DECL.  */
7396
7397 void
7398 make_rtl_for_local_static (decl)
7399      tree decl;
7400 {
7401   tree type = TREE_TYPE (decl);
7402   const char *asmspec = NULL;
7403
7404   if (TREE_READONLY (decl)
7405       && DECL_INITIAL (decl) != NULL_TREE
7406       && DECL_INITIAL (decl) != error_mark_node
7407       && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
7408       && ! TREE_SIDE_EFFECTS (decl)
7409       && ! TREE_PUBLIC (decl)
7410       && ! DECL_EXTERNAL (decl)
7411       && ! TYPE_NEEDS_DESTRUCTOR (type)
7412       && ! TREE_ADDRESSABLE (decl)
7413       && DECL_MODE (decl) != BLKmode)
7414     {
7415       /* As an optimization, we try to put register-sized static
7416          constants in a register, rather than writing them out.  If we
7417          take the address of the constant later, we'll make RTL for it
7418          at that point.  */
7419       DECL_RTL (decl) = gen_reg_rtx (DECL_MODE (decl));
7420       store_expr (DECL_INITIAL (decl), DECL_RTL (decl), 0);
7421       TREE_ASM_WRITTEN (decl) = 1;
7422       return;
7423     }
7424
7425   if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
7426     {
7427       /* The only way this situaton can occur is if the
7428          user specified a name for this DECL using the
7429          `attribute' syntax.  */
7430       asmspec = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
7431       DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
7432     }
7433
7434   rest_of_decl_compilation (decl, asmspec, /*top_level=*/0, /*at_end=*/0);
7435 }
7436
7437 /* The old ARM scoping rules injected variables declared in the
7438    initialization statement of a for-statement into the surrounding
7439    scope.  We support this usage, in order to be backward-compatible.
7440    DECL is a just-declared VAR_DECL; if necessary inject its
7441    declaration into the surrounding scope.  */
7442
7443 void
7444 maybe_inject_for_scope_var (decl)
7445      tree decl;
7446 {
7447   if (current_binding_level->is_for_scope)
7448     {
7449       struct binding_level *outer
7450         = current_binding_level->level_chain;
7451
7452       /* Check to see if the same name is already bound at the outer
7453          level, either because it was directly declared, or because a
7454          dead for-decl got preserved.  In either case, the code would
7455          not have been valid under the ARM scope rules, so clear
7456          is_for_scope for the current_binding_level.
7457
7458          Otherwise, we need to preserve the temp slot for decl to last
7459          into the outer binding level.  */
7460
7461       tree outer_binding
7462         = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
7463
7464       if (outer_binding && BINDING_LEVEL (outer_binding) == outer
7465           && (TREE_CODE (BINDING_VALUE (outer_binding))
7466               == VAR_DECL)
7467           && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
7468         {
7469           BINDING_VALUE (outer_binding)
7470             = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
7471           current_binding_level->is_for_scope = 0;
7472         }
7473       else if (DECL_IN_MEMORY_P (decl))
7474         preserve_temp_slots (DECL_RTL (decl));
7475     }
7476 }
7477
7478 /* Generate code to initialize DECL (a local variable).  */
7479
7480 void
7481 initialize_local_var (decl, init, flags)
7482      tree decl;
7483      tree init;
7484      int flags;
7485 {
7486   tree type = TREE_TYPE (decl);
7487
7488   /* If the type is bogus, don't bother initializing the variable.  */
7489   if (type == error_mark_node)
7490     return;
7491
7492   if (DECL_SIZE (decl) == NULL_TREE && !TREE_STATIC (decl))
7493     {
7494       /* If we used it already as memory, it must stay in memory.  */
7495       DECL_INITIAL (decl) = NULL_TREE;
7496       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
7497     }
7498
7499   /* Local statics are handled differently from ordinary automatic
7500      variables.  */
7501   if (TREE_STATIC (decl))
7502     {
7503       if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7504           || TYPE_NEEDS_DESTRUCTOR (type))
7505         expand_static_init (decl, init);
7506       return;
7507     }
7508
7509   if (DECL_SIZE (decl) && type != error_mark_node)
7510     {
7511       int already_used;
7512
7513       /* Compute and store the initial value.  */
7514       already_used = TREE_USED (decl) || TREE_USED (type);
7515
7516       if (init || TYPE_NEEDS_CONSTRUCTING (type))
7517         {
7518           int saved_stmts_are_full_exprs_p;
7519
7520           emit_line_note (DECL_SOURCE_FILE (decl),
7521                           DECL_SOURCE_LINE (decl));
7522           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p;
7523           stmts_are_full_exprs_p = 1;
7524           finish_expr_stmt (build_aggr_init (decl, init, flags));
7525           stmts_are_full_exprs_p = saved_stmts_are_full_exprs_p;
7526         }
7527
7528       /* Set this to 0 so we can tell whether an aggregate which was
7529          initialized was ever used.  Don't do this if it has a
7530          destructor, so we don't complain about the 'resource
7531          allocation is initialization' idiom.  Now set
7532          attribute((unused)) on types so decls of that type will be
7533          marked used. (see TREE_USED, above.)  */
7534       if (TYPE_NEEDS_CONSTRUCTING (type)
7535           && ! already_used
7536           && !TYPE_NEEDS_DESTRUCTOR (type)
7537           && DECL_NAME (decl))
7538         TREE_USED (decl) = 0;
7539       else if (already_used)
7540         TREE_USED (decl) = 1;
7541     }
7542 }
7543
7544 /* Generate code to destroy DECL (a local variable).  */
7545
7546 void
7547 destroy_local_var (decl)
7548      tree decl;
7549 {
7550   tree type = TREE_TYPE (decl);
7551   tree cleanup;
7552
7553   /* Only variables get cleaned up.  */
7554   if (TREE_CODE (decl) != VAR_DECL)
7555     return;
7556
7557   /* And only things with destructors need cleaning up.  */
7558   if (!TYPE_NEEDS_DESTRUCTOR (type))
7559     return;
7560
7561   if (TREE_CODE (decl) == VAR_DECL &&
7562       (DECL_EXTERNAL (decl) || TREE_STATIC (decl)))
7563     /* We don't clean up things that aren't defined in this
7564        translation unit, or that need a static cleanup.  The latter
7565        are handled by finish_file.  */
7566     return;
7567
7568   /* Compute the cleanup.  */
7569   cleanup = maybe_build_cleanup (decl);
7570
7571   /* Record the cleanup required for this declaration.  */
7572   if (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node
7573       && cleanup)
7574     finish_decl_cleanup (decl, cleanup);
7575 }
7576
7577 /* Let the back-end know about DECL.  */
7578
7579 void
7580 emit_local_var (decl)
7581      tree decl;
7582 {
7583   /* Create RTL for this variable.  */
7584   if (DECL_RTL (decl))
7585     /* Only a RESULT_DECL should have non-NULL RTL when
7586                      arriving here.  All other local variables are
7587                      assigned RTL in this function.  */
7588     my_friendly_assert (TREE_CODE (decl) == RESULT_DECL,
7589                         19990828);
7590   else
7591     {
7592       if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
7593         /* The user must have specified an assembler name for this
7594            variable.  Set that up now.  */
7595         rest_of_decl_compilation
7596           (decl, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
7597            /*top_level=*/0, /*at_end=*/0);
7598       else
7599         expand_decl (decl);
7600     }
7601
7602   /* Actually do the initialization.  */
7603   expand_start_target_temps ();
7604   expand_decl_init (decl);
7605   expand_end_target_temps ();
7606 }
7607
7608 /* Finish processing of a declaration;
7609    install its line number and initial value.
7610    If the length of an array type is not known before,
7611    it must be determined now, from the initial value, or it is an error.
7612
7613    Call `pop_obstacks' iff NEED_POP is nonzero.
7614
7615    For C++, `cp_finish_decl' must be fairly evasive:  it must keep initializers
7616    for aggregates that have constructors alive on the permanent obstack,
7617    so that the global initializing functions can be written at the end.
7618
7619    INIT0 holds the value of an initializer that should be allowed to escape
7620    the normal rules.
7621
7622    FLAGS is LOOKUP_ONLYCONVERTING is the = init syntax was used, else 0
7623    if the (init) syntax was used.
7624
7625    For functions that take default parameters, DECL points to its
7626    "maximal" instantiation.  `cp_finish_decl' must then also declared its
7627    subsequently lower and lower forms of instantiation, checking for
7628    ambiguity as it goes.  This can be sped up later.  */
7629
7630 void
7631 cp_finish_decl (decl, init, asmspec_tree, need_pop, flags)
7632      tree decl, init;
7633      tree asmspec_tree;
7634      int need_pop;
7635      int flags;
7636 {
7637   register tree type;
7638   tree ttype = NULL_TREE;
7639   int temporary = allocation_temporary_p ();
7640   const char *asmspec = NULL;
7641   int was_readonly = 0;
7642
7643   /* If this is 0, then we did not change obstacks.  */
7644   if (! decl)
7645     {
7646       if (init)
7647         error ("assignment (not initialization) in declaration");
7648       return;
7649     }
7650
7651   /* If a name was specified, get the string.  */
7652   if (asmspec_tree)
7653       asmspec = TREE_STRING_POINTER (asmspec_tree);
7654
7655   if (init && TREE_CODE (init) == NAMESPACE_DECL)
7656     {
7657       cp_error ("Cannot initialize `%D' to namespace `%D'",
7658                 decl, init);
7659       init = NULL_TREE;
7660     }
7661
7662   if (current_class_type
7663       && DECL_REAL_CONTEXT (decl) == current_class_type
7664       && TYPE_BEING_DEFINED (current_class_type)
7665       && (DECL_INITIAL (decl) || init))
7666     DECL_DEFINED_IN_CLASS_P (decl) = 1;
7667
7668   if (TREE_CODE (decl) == VAR_DECL
7669       && DECL_CONTEXT (decl)
7670       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
7671       && DECL_CONTEXT (decl) != current_namespace
7672       && init)
7673     {
7674       /* Leave the namespace of the object. */
7675       pop_decl_namespace ();
7676     }
7677
7678   type = TREE_TYPE (decl);
7679
7680   if (type == error_mark_node)
7681     {
7682       if (toplevel_bindings_p () && temporary)
7683         end_temporary_allocation ();
7684
7685       return;
7686     }
7687
7688   /* Add this declaration to the statement-tree.  */
7689   if (building_stmt_tree ()
7690       && TREE_CODE (current_scope ()) == FUNCTION_DECL)
7691     add_decl_stmt (decl);
7692
7693   if (TYPE_HAS_MUTABLE_P (type))
7694     TREE_READONLY (decl) = 0;
7695
7696   if (processing_template_decl)
7697     {
7698       if (init && DECL_INITIAL (decl))
7699         DECL_INITIAL (decl) = init;
7700       goto finish_end0;
7701     }
7702
7703   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
7704   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
7705
7706   /* Take care of TYPE_DECLs up front.  */
7707   if (TREE_CODE (decl) == TYPE_DECL)
7708     {
7709       if (init && DECL_INITIAL (decl))
7710         {
7711           /* typedef foo = bar; store the type of bar as the type of foo.  */
7712           TREE_TYPE (decl) = type = TREE_TYPE (init);
7713           DECL_INITIAL (decl) = init = NULL_TREE;
7714         }
7715       if (type != error_mark_node
7716           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
7717         {
7718           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
7719             cp_warning ("shadowing previous type declaration of `%#D'", decl);
7720           set_identifier_type_value (DECL_NAME (decl), type);
7721           CLASSTYPE_GOT_SEMICOLON (type) = 1;
7722         }
7723       GNU_xref_decl (current_function_decl, decl);
7724
7725       /* If we have installed this as the canonical typedef for this
7726          type, and that type has not been defined yet, delay emitting
7727          the debug information for it, as we will emit it later.  */
7728       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
7729           && TYPE_SIZE (TREE_TYPE (decl)) == NULL_TREE)
7730         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
7731
7732       rest_of_decl_compilation (decl, NULL_PTR,
7733                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
7734       goto finish_end;
7735     }
7736
7737   if (TREE_CODE (decl) != FUNCTION_DECL)
7738     ttype = target_type (type);
7739
7740   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
7741       && TYPE_NEEDS_CONSTRUCTING (type))
7742     {
7743       /* Currently, GNU C++ puts constants in text space, making them
7744          impossible to initialize.  In the future, one would hope for
7745          an operating system which understood the difference between
7746          initialization and the running of a program.  */
7747       was_readonly = 1;
7748       TREE_READONLY (decl) = 0;
7749     }
7750
7751   if (TREE_CODE (decl) == FIELD_DECL && asmspec)
7752     {
7753       /* This must override the asm specifier which was placed by
7754          grokclassfn.  Lay this out fresh.  */
7755       DECL_RTL (TREE_TYPE (decl)) = NULL_RTX;
7756       DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
7757       make_decl_rtl (decl, asmspec, 0);
7758     }
7759
7760   /* Deduce size of array from initialization, if not already known.  */
7761   maybe_deduce_size_from_array_init (decl, init);
7762   init = check_initializer (decl, init);
7763
7764   GNU_xref_decl (current_function_decl, decl);
7765
7766   /* For top-level declaration, the initial value was read in
7767      the temporary obstack.  MAXINDEX, rtl, etc. to be made below
7768      must go in the permanent obstack; but don't discard the
7769      temporary data yet.  */
7770
7771   if (toplevel_bindings_p () && temporary)
7772     end_temporary_allocation ();
7773
7774   if (TREE_CODE (decl) == VAR_DECL)
7775     layout_var_decl (decl);
7776
7777   /* Output the assembler code and/or RTL code for variables and functions,
7778      unless the type is an undefined structure or union.
7779      If not, it will get done when the type is completed.  */
7780   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
7781       || TREE_CODE (decl) == RESULT_DECL)
7782     {
7783       if (TREE_CODE (decl) == VAR_DECL)
7784         maybe_commonize_var (decl);
7785
7786       make_rtl_for_nonlocal_decl (decl, init, asmspec);
7787
7788       if (TREE_CODE (type) == FUNCTION_TYPE
7789           || TREE_CODE (type) == METHOD_TYPE)
7790         abstract_virtuals_error (decl,
7791                                  strip_array_types (TREE_TYPE (type)));
7792       else
7793         abstract_virtuals_error (decl, strip_array_types (type));
7794
7795       if (TREE_CODE (decl) == FUNCTION_DECL)
7796         ;
7797       else if (DECL_EXTERNAL (decl)
7798                && ! (DECL_LANG_SPECIFIC (decl)
7799                      && DECL_NOT_REALLY_EXTERN (decl)))
7800         {
7801           if (init)
7802             DECL_INITIAL (decl) = init;
7803         }
7804       else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
7805         {
7806           /* This is a local declaration.  */
7807           if (doing_semantic_analysis_p ())
7808             maybe_inject_for_scope_var (decl);
7809           /* Initialize the local variable.  But, if we're building a
7810              statement-tree, we'll do the initialization when we
7811              expand the tree.  */
7812           if (processing_template_decl)
7813             {
7814               if (init || DECL_INITIAL (decl) == error_mark_node)
7815                 DECL_INITIAL (decl) = init;
7816             }
7817           else
7818             {
7819               /* If we're not building RTL, then we need to do so
7820                  now.  */
7821               if (!building_stmt_tree ())
7822                 emit_local_var (decl);
7823               /* Initialize the variable.  */
7824               initialize_local_var (decl, init, flags);
7825               /* Clean up the variable.  */
7826               destroy_local_var (decl);
7827             }
7828         }
7829       else if (TREE_STATIC (decl) && type != error_mark_node)
7830         {
7831           /* Cleanups for static variables are handled by `finish_file'.  */
7832           if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7833               || TYPE_NEEDS_DESTRUCTOR (type))
7834             expand_static_init (decl, init);
7835         }
7836     finish_end0:
7837
7838       /* Undo call to `pushclass' that was done in `start_decl'
7839          due to initialization of qualified member variable.
7840          I.e., Foo::x = 10;  */
7841       {
7842         tree context = DECL_REAL_CONTEXT (decl);
7843         if (context
7844             && TREE_CODE_CLASS (TREE_CODE (context)) == 't'
7845             && (TREE_CODE (decl) == VAR_DECL
7846                 /* We also have a pushclass done that we need to undo here
7847                    if we're at top level and declare a method.  */
7848                 || TREE_CODE (decl) == FUNCTION_DECL)
7849             /* If size hasn't been set, we're still defining it,
7850                and therefore inside the class body; don't pop
7851                the binding level..  */
7852             && TYPE_SIZE (context) != NULL_TREE
7853             && context == current_class_type)
7854           pop_nested_class ();
7855       }
7856     }
7857
7858  finish_end:
7859
7860   /* If requested, warn about definitions of large data objects.  */
7861
7862   if (warn_larger_than
7863       && ! processing_template_decl
7864       && (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL)
7865       && !DECL_EXTERNAL (decl))
7866     {
7867       register tree decl_size = DECL_SIZE (decl);
7868
7869       if (decl_size && TREE_CODE (decl_size) == INTEGER_CST)
7870         {
7871           unsigned units = TREE_INT_CST_LOW (decl_size) / BITS_PER_UNIT;
7872
7873           if (units > larger_than_size)
7874             warning_with_decl (decl, "size of `%s' is %u bytes", units);
7875         }
7876     }
7877
7878   if (need_pop)
7879     /* Resume permanent allocation, if not within a function.  The
7880        corresponding push_obstacks_nochange is in start_decl,
7881        start_method, groktypename, and in grokfield.  */
7882     pop_obstacks ();
7883
7884   if (was_readonly)
7885     TREE_READONLY (decl) = 1;
7886 }
7887
7888 /* This is here for a midend callback from c-common.c */
7889
7890 void
7891 finish_decl (decl, init, asmspec_tree)
7892      tree decl, init;
7893      tree asmspec_tree;
7894 {
7895   cp_finish_decl (decl, init, asmspec_tree, 1, 0);
7896 }
7897
7898 /* Generate code to handle the destruction of the function-scoped
7899    static variable DECL.  */
7900
7901 static void
7902 destroy_local_static (decl)
7903      tree decl;
7904 {
7905   tree cleanup, fcall;
7906   tree compound_stmt;
7907   int saved_flag_access_control;
7908
7909   if (atexit_node == 0)
7910     {
7911       tree atexit_fndecl, PFV, pfvlist;
7912       /* Remember this information until end of file.  */
7913       push_obstacks (&permanent_obstack, &permanent_obstack);
7914       PFV = build_pointer_type (build_function_type
7915                                 (void_type_node, void_list_node));
7916
7917       pfvlist = tree_cons (NULL_TREE, PFV, void_list_node);
7918
7919       push_lang_context (lang_name_c);
7920       /* Note that we do not call pushdecl for this function;
7921          there's no reason that this declaration should be
7922          accessible to anyone.  */
7923       atexit_fndecl
7924         = define_function ("atexit",
7925                            build_function_type (void_type_node,
7926                                                 pfvlist),
7927                            /*pfn=*/0, NULL_PTR);
7928       mark_used (atexit_fndecl);
7929       atexit_node = default_conversion (atexit_fndecl);
7930       pop_lang_context ();
7931       pop_obstacks ();
7932     }
7933
7934   /* Call build_cleanup before we enter the anonymous function so that
7935      any access checks will be done relative to the current scope,
7936      rather than the scope of the anonymous function.  */
7937   build_cleanup (decl);
7938
7939   /* Now start the function.  */
7940   cleanup = start_anon_func ();
7941
7942   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
7943      to the original function, rather than the anonymous one.  That
7944      will make the back-end think that nested functions are in use,
7945      which causes confusion.  */
7946   saved_flag_access_control = flag_access_control;
7947   flag_access_control = 0;
7948   fcall = build_cleanup (decl);
7949   flag_access_control = saved_flag_access_control;
7950
7951   /* Create the body of the anonymous function.  */
7952   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
7953   finish_expr_stmt (fcall);
7954   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
7955   end_anon_func ();
7956
7957   /* Call atexit with the cleanup function.  */
7958   mark_addressable (cleanup);
7959   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
7960   fcall = build_function_call (atexit_node,
7961                                tree_cons (NULL_TREE,
7962                                           cleanup,
7963                                           NULL_TREE));
7964   finish_expr_stmt (fcall);
7965 }
7966
7967 void
7968 expand_static_init (decl, init)
7969      tree decl;
7970      tree init;
7971 {
7972   tree oldstatic = value_member (decl, static_aggregates);
7973
7974   if (oldstatic)
7975     {
7976       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
7977         cp_error ("multiple initializations given for `%D'", decl);
7978     }
7979   else if (! toplevel_bindings_p ())
7980     {
7981       /* Emit code to perform this initialization but once.  */
7982       tree temp;
7983       tree if_stmt;
7984       tree then_clause;
7985       tree assignment;
7986       tree temp_init;
7987
7988       /* Remember this information until end of file.  */
7989       push_obstacks (&permanent_obstack, &permanent_obstack);
7990
7991       /* Emit code to perform this initialization but once.  This code
7992          looks like:
7993
7994            static int temp = 0;
7995            if (!temp) {
7996              // Do initialization.
7997              temp = 1;
7998              // Register variable for destruction at end of program.
7999            }
8000
8001          Note that the `temp' variable is only set to 1 *after* the
8002          initialization is complete.  This ensures that an exception,
8003          thrown during the construction, will cause the variable to
8004          reinitialized when we pass through this code again, as per:
8005
8006            [stmt.dcl]
8007
8008            If the initialization exits by throwing an exception, the
8009            initialization is not complete, so it will be tried again
8010            the next time control enters the declaration.
8011
8012          In theory, this process should be thread-safe, too; multiple
8013          threads should not be able to initialize the variable more
8014          than once.  We don't yet attempt to ensure thread-safety.  */
8015       temp = get_temp_name (integer_type_node, 1);
8016       rest_of_decl_compilation (temp, NULL_PTR, 0, 0);
8017
8018       /* Begin the conditional initialization.  */
8019       if_stmt = begin_if_stmt ();
8020       finish_if_stmt_cond (build_binary_op (EQ_EXPR, temp,
8021                                             integer_zero_node),
8022                            if_stmt);
8023       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8024
8025       /* Do the initialization itself.  */
8026       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8027           || (init && TREE_CODE (init) == TREE_LIST))
8028         assignment = build_aggr_init (decl, init, 0);
8029       else if (init)
8030         /* The initialization we're doing here is just a bitwise
8031            copy.  */
8032         assignment = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
8033       else
8034         assignment = NULL_TREE;
8035
8036       /* Once the assignment is complete, set TEMP to 1.  Since the
8037          construction of the static object is complete at this point,
8038          we want to make sure TEMP is set to 1 even if a temporary
8039          constructed during the initialization throws an exception
8040          when it is destroyed.  So, we combine the initialization and
8041          the assignment to TEMP into a single expression, ensuring
8042          that when we call finish_expr_stmt the cleanups will not be
8043          run until after TEMP is set to 1.  */
8044       temp_init = build_modify_expr (temp, NOP_EXPR, integer_one_node);
8045       if (assignment)
8046         {
8047           assignment = tree_cons (NULL_TREE, assignment,
8048                                   build_tree_list (NULL_TREE,
8049                                                    temp_init));
8050           assignment = build_compound_expr (assignment);
8051         }
8052       else
8053         assignment = temp_init;
8054       finish_expr_stmt (assignment);
8055
8056       /* Use atexit to register a function for destroying this static
8057          variable.  */
8058       if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (decl)))
8059         destroy_local_static (decl);
8060
8061       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8062       finish_then_clause (if_stmt);
8063       finish_if_stmt ();
8064
8065       /* Resume old (possibly temporary) allocation.  */
8066       pop_obstacks ();
8067     }
8068   else
8069     {
8070       /* This code takes into account memory allocation policy of
8071          `start_decl'.  Namely, if TYPE_NEEDS_CONSTRUCTING does not
8072          hold for this object, then we must make permanent the storage
8073          currently in the temporary obstack.  */
8074       if (!TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
8075         preserve_initializer ();
8076       static_aggregates = tree_cons (init, decl, static_aggregates);
8077     }
8078 }
8079
8080 /* Finish the declaration of a catch-parameter.  */
8081
8082 tree
8083 start_handler_parms (declspecs, declarator)
8084      tree declspecs;
8085      tree declarator;
8086 {
8087   tree decl;
8088   if (declspecs)
8089     {
8090       decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8091                              1, NULL_TREE);
8092       if (decl == NULL_TREE)
8093         error ("invalid catch parameter");
8094     }
8095   else
8096     decl = NULL_TREE;
8097
8098   return decl;
8099 }
8100
8101 \f
8102 /* Make TYPE a complete type based on INITIAL_VALUE.
8103    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8104    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
8105
8106 int
8107 complete_array_type (type, initial_value, do_default)
8108      tree type, initial_value;
8109      int do_default;
8110 {
8111   register tree maxindex = NULL_TREE;
8112   int value = 0;
8113
8114   /* Allocate on the same obstack as TYPE.  */
8115   push_obstacks (TYPE_OBSTACK (type), TYPE_OBSTACK (type));
8116
8117   if (initial_value)
8118     {
8119       /* Note MAXINDEX  is really the maximum index,
8120          one less than the size.  */
8121       if (TREE_CODE (initial_value) == STRING_CST)
8122         {
8123           int eltsize
8124             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8125           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8126                                    / eltsize) - 1, 0);
8127         }
8128       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8129         {
8130           tree elts = CONSTRUCTOR_ELTS (initial_value);
8131           maxindex = size_binop (MINUS_EXPR, integer_zero_node, size_one_node);
8132           for (; elts; elts = TREE_CHAIN (elts))
8133             {
8134               if (TREE_PURPOSE (elts))
8135                 maxindex = TREE_PURPOSE (elts);
8136               else
8137                 maxindex = size_binop (PLUS_EXPR, maxindex, size_one_node);
8138             }
8139           maxindex = copy_node (maxindex);
8140         }
8141       else
8142         {
8143           /* Make an error message unless that happened already.  */
8144           if (initial_value != error_mark_node)
8145             value = 1;
8146           else
8147             initial_value = NULL_TREE;
8148
8149           /* Prevent further error messages.  */
8150           maxindex = build_int_2 (0, 0);
8151         }
8152     }
8153
8154   if (!maxindex)
8155     {
8156       if (do_default)
8157         maxindex = build_int_2 (0, 0);
8158       value = 2;
8159     }
8160
8161   if (maxindex)
8162     {
8163       tree itype;
8164       tree domain;
8165
8166       domain = build_index_type (maxindex);
8167       TYPE_DOMAIN (type) = domain;
8168
8169       if (! TREE_TYPE (maxindex))
8170         TREE_TYPE (maxindex) = domain;
8171       if (initial_value)
8172         itype = TREE_TYPE (initial_value);
8173       else
8174         itype = NULL;
8175       if (itype && !TYPE_DOMAIN (itype))
8176         TYPE_DOMAIN (itype) = domain;
8177       /* The type of the main variant should never be used for arrays
8178          of different sizes.  It should only ever be completed with the
8179          size of the array.  */
8180       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8181         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8182     }
8183
8184   pop_obstacks();
8185
8186   /* Lay out the type now that we can get the real answer.  */
8187
8188   layout_type (type);
8189
8190   return value;
8191 }
8192 \f
8193 /* Return zero if something is declared to be a member of type
8194    CTYPE when in the context of CUR_TYPE.  STRING is the error
8195    message to print in that case.  Otherwise, quietly return 1.  */
8196
8197 static int
8198 member_function_or_else (ctype, cur_type, string)
8199      tree ctype, cur_type;
8200      const char *string;
8201 {
8202   if (ctype && ctype != cur_type)
8203     {
8204       error (string, TYPE_NAME_STRING (ctype));
8205       return 0;
8206     }
8207   return 1;
8208 }
8209 \f
8210 /* Subroutine of `grokdeclarator'.  */
8211
8212 /* Generate errors possibly applicable for a given set of specifiers.
8213    This is for ARM $7.1.2.  */
8214
8215 static void
8216 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8217      tree object;
8218      const char *type;
8219      int virtualp, quals, friendp, raises, inlinep;
8220 {
8221   if (virtualp)
8222     cp_error ("`%D' declared as a `virtual' %s", object, type);
8223   if (inlinep)
8224     cp_error ("`%D' declared as an `inline' %s", object, type);
8225   if (quals)
8226     cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8227               object, type);
8228   if (friendp)
8229     cp_error_at ("`%D' declared as a friend", object);
8230   if (raises)
8231     cp_error_at ("`%D' declared with an exception specification", object);
8232 }
8233
8234 /* CTYPE is class type, or null if non-class.
8235    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8236    or METHOD_TYPE.
8237    DECLARATOR is the function's name.
8238    VIRTUALP is truthvalue of whether the function is virtual or not.
8239    FLAGS are to be passed through to `grokclassfn'.
8240    QUALS are qualifiers indicating whether the function is `const'
8241    or `volatile'.
8242    RAISES is a list of exceptions that this function can raise.
8243    CHECK is 1 if we must find this method in CTYPE, 0 if we should
8244    not look, and -1 if we should not call `grokclassfn' at all.
8245
8246    Returns `NULL_TREE' if something goes wrong, after issuing
8247    applicable error messages.  */
8248
8249 static tree
8250 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8251             raises, check, friendp, publicp, inlinep, funcdef_flag,
8252             template_count, in_namespace)
8253      tree ctype, type;
8254      tree declarator;
8255      tree orig_declarator;
8256      int virtualp;
8257      enum overload_flags flags;
8258      tree quals, raises;
8259      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8260      tree in_namespace;
8261 {
8262   tree cname, decl;
8263   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8264   int has_default_arg = 0;
8265   tree t;
8266
8267   if (ctype)
8268     cname = TREE_CODE (TYPE_NAME (ctype)) == TYPE_DECL
8269       ? TYPE_IDENTIFIER (ctype) : TYPE_NAME (ctype);
8270   else
8271     cname = NULL_TREE;
8272
8273   if (raises)
8274     {
8275       type = build_exception_variant (type, raises);
8276     }
8277
8278   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8279   /* Propagate volatile out from type to decl. */
8280   if (TYPE_VOLATILE (type))
8281     TREE_THIS_VOLATILE (decl) = 1;
8282
8283   /* If this decl has namespace scope, set that up.  */
8284   if (in_namespace)
8285     set_decl_namespace (decl, in_namespace, friendp);
8286   else if (publicp && ! ctype)
8287     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8288
8289   /* `main' and builtins have implicit 'C' linkage.  */
8290   if ((MAIN_NAME_P (declarator)
8291        || (IDENTIFIER_LENGTH (declarator) > 10
8292            && IDENTIFIER_POINTER (declarator)[0] == '_'
8293            && IDENTIFIER_POINTER (declarator)[1] == '_'
8294            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8295       && current_lang_name == lang_name_cplusplus
8296       && ctype == NULL_TREE
8297       /* NULL_TREE means global namespace.  */
8298       && DECL_CONTEXT (decl) == NULL_TREE)
8299     DECL_LANGUAGE (decl) = lang_c;
8300
8301   /* Should probably propagate const out from type to decl I bet (mrs).  */
8302   if (staticp)
8303     {
8304       DECL_STATIC_FUNCTION_P (decl) = 1;
8305       DECL_CONTEXT (decl) = ctype;
8306     }
8307
8308   if (ctype)
8309     DECL_CLASS_CONTEXT (decl) = ctype;
8310
8311   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8312     {
8313       if (processing_template_decl)
8314         error ("cannot declare `main' to be a template");
8315       if (inlinep)
8316         error ("cannot declare `main' to be inline");
8317       else if (! publicp)
8318         error ("cannot declare `main' to be static");
8319       inlinep = 0;
8320       publicp = 1;
8321     }
8322
8323   /* Members of anonymous types and local classes have no linkage; make
8324      them internal.  */
8325   if (ctype && (ANON_AGGRNAME_P (TYPE_IDENTIFIER (ctype))
8326                 || hack_decl_function_context (TYPE_MAIN_DECL (ctype))))
8327     publicp = 0;
8328
8329   if (publicp)
8330     {
8331       /* [basic.link]: A name with no linkage (notably, the name of a class
8332          or enumeration declared in a local scope) shall not be used to
8333          declare an entity with linkage.
8334
8335          Only check this for public decls for now.  */
8336       t = no_linkage_check (TREE_TYPE (decl));
8337       if (t)
8338         {
8339           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8340             {
8341               if (DECL_LANGUAGE (decl) == lang_c)
8342                 /* Allow this; it's pretty common in C.  */;
8343               else
8344                 cp_pedwarn ("non-local function `%#D' uses anonymous type",
8345                             decl);
8346             }
8347           else
8348             cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8349                         decl, t);
8350         }
8351     }
8352
8353   TREE_PUBLIC (decl) = publicp;
8354   if (! publicp)
8355     {
8356       DECL_INTERFACE_KNOWN (decl) = 1;
8357       DECL_NOT_REALLY_EXTERN (decl) = 1;
8358     }
8359
8360   if (inlinep)
8361     DECL_THIS_INLINE (decl) = DECL_INLINE (decl) = 1;
8362
8363   DECL_EXTERNAL (decl) = 1;
8364   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
8365     {
8366       cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8367                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
8368       quals = NULL_TREE;
8369     }
8370
8371   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
8372     grok_op_properties (decl, virtualp, check < 0);
8373
8374   if (ctype && hack_decl_function_context (decl))
8375     DECL_NO_STATIC_CHAIN (decl) = 1;
8376
8377   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
8378     if (TREE_PURPOSE (t)
8379         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
8380       {
8381         has_default_arg = 1;
8382         break;
8383       }
8384
8385   if (friendp
8386       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
8387     {
8388       if (funcdef_flag)
8389         cp_error
8390           ("defining explicit specialization `%D' in friend declaration",
8391            orig_declarator);
8392       else
8393         {
8394           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8395             {
8396               /* Something like `template <class T> friend void f<T>()'.  */
8397               cp_error ("template-id `%D' in declaration of primary template",
8398                         orig_declarator);
8399               return NULL_TREE;
8400             }
8401
8402
8403           /* A friend declaration of the form friend void f<>().  Record
8404              the information in the TEMPLATE_ID_EXPR.  */
8405           SET_DECL_IMPLICIT_INSTANTIATION (decl);
8406           DECL_TEMPLATE_INFO (decl)
8407             = tree_cons (TREE_OPERAND (orig_declarator, 0),
8408                          TREE_OPERAND (orig_declarator, 1),
8409                          NULL_TREE);
8410
8411           if (has_default_arg)
8412             {
8413               cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8414                         decl);
8415               return NULL_TREE;
8416             }
8417
8418           if (inlinep)
8419             {
8420               cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
8421                         decl);
8422               return NULL_TREE;
8423             }
8424         }
8425     }
8426
8427   if (has_default_arg)
8428     add_defarg_fn (decl);
8429
8430   /* Plain overloading: will not be grok'd by grokclassfn.  */
8431   if (! ctype && ! processing_template_decl
8432       && DECL_LANGUAGE (decl) != lang_c
8433       && (! DECL_USE_TEMPLATE (decl) || name_mangling_version < 1))
8434     set_mangled_name_for_decl (decl);
8435
8436   if (funcdef_flag)
8437     /* Make the init_value nonzero so pushdecl knows this is not
8438        tentative.  error_mark_node is replaced later with the BLOCK.  */
8439     DECL_INITIAL (decl) = error_mark_node;
8440
8441   /* Caller will do the rest of this.  */
8442   if (check < 0)
8443     return decl;
8444
8445   if (flags == NO_SPECIAL && ctype && constructor_name (cname) == declarator)
8446     {
8447       tree tmp;
8448       /* Just handle constructors here.  We could do this
8449          inside the following if stmt, but I think
8450          that the code is more legible by breaking this
8451          case out.  See comments below for what each of
8452          the following calls is supposed to do.  */
8453       DECL_CONSTRUCTOR_P (decl) = 1;
8454
8455       grokclassfn (ctype, decl, flags, quals);
8456
8457       decl = check_explicit_specialization (orig_declarator, decl,
8458                                             template_count,
8459                                             2 * (funcdef_flag != 0) +
8460                                             4 * (friendp != 0));
8461       if (decl == error_mark_node)
8462         return NULL_TREE;
8463
8464       if ((! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
8465           && check)
8466         {
8467           tmp = check_classfn (ctype, decl);
8468
8469           if (tmp && TREE_CODE (tmp) == TEMPLATE_DECL)
8470             tmp = DECL_TEMPLATE_RESULT(tmp);
8471
8472           if (tmp && DECL_ARTIFICIAL (tmp))
8473             cp_error ("definition of implicitly-declared `%D'", tmp);
8474           if (tmp && duplicate_decls (decl, tmp))
8475             return tmp;
8476         }
8477       if (! grok_ctor_properties (ctype, decl))
8478         return NULL_TREE;
8479     }
8480   else
8481     {
8482       tree tmp;
8483
8484       /* Function gets the ugly name, field gets the nice one.
8485          This call may change the type of the function (because
8486          of default parameters)!  */
8487       if (ctype != NULL_TREE)
8488         grokclassfn (ctype, decl, flags, quals);
8489
8490       decl = check_explicit_specialization (orig_declarator, decl,
8491                                             template_count,
8492                                             2 * (funcdef_flag != 0) +
8493                                             4 * (friendp != 0));
8494       if (decl == error_mark_node)
8495         return NULL_TREE;
8496
8497       if (ctype != NULL_TREE
8498           && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
8499           && check)
8500         {
8501           tmp = check_classfn (ctype, decl);
8502
8503           if (tmp && TREE_CODE (tmp) == TEMPLATE_DECL)
8504             tmp = DECL_TEMPLATE_RESULT (tmp);
8505
8506           if (tmp && DECL_STATIC_FUNCTION_P (tmp)
8507               && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
8508             {
8509               /* Remove the `this' parm added by grokclassfn.
8510                  XXX Isn't this done in start_function, too?  */
8511               revert_static_member_fn (&decl, NULL, NULL);
8512               last_function_parms = TREE_CHAIN (last_function_parms);
8513             }
8514           if (tmp && DECL_ARTIFICIAL (tmp))
8515             cp_error ("definition of implicitly-declared `%D'", tmp);
8516           if (tmp)
8517             {
8518               /* Attempt to merge the declarations.  This can fail, in
8519                  the case of some illegal specialization declarations.  */
8520               if (!duplicate_decls (decl, tmp))
8521                 cp_error ("no `%#D' member function declared in class `%T'",
8522                           decl, ctype);
8523               return tmp;
8524             }
8525         }
8526
8527       if (ctype == NULL_TREE || check)
8528         return decl;
8529
8530       if (virtualp)
8531         {
8532           DECL_VIRTUAL_P (decl) = 1;
8533           if (DECL_VINDEX (decl) == NULL_TREE)
8534             DECL_VINDEX (decl) = error_mark_node;
8535           IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
8536         }
8537     }
8538   return decl;
8539 }
8540
8541 static tree
8542 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
8543      tree type;
8544      tree declarator;
8545      RID_BIT_TYPE *specbits_in;
8546      int initialized;
8547      int constp;
8548      tree in_namespace;
8549 {
8550   tree decl;
8551   RID_BIT_TYPE specbits;
8552
8553   specbits = *specbits_in;
8554
8555   if (TREE_CODE (type) == OFFSET_TYPE)
8556     {
8557       /* If you declare a static member so that it
8558          can be initialized, the code will reach here.  */
8559       tree basetype = TYPE_OFFSET_BASETYPE (type);
8560       type = TREE_TYPE (type);
8561       decl = build_lang_decl (VAR_DECL, declarator, type);
8562       DECL_CONTEXT (decl) = basetype;
8563       DECL_CLASS_CONTEXT (decl) = basetype;
8564       DECL_ASSEMBLER_NAME (decl) = build_static_name (basetype, declarator);
8565     }
8566   else
8567     {
8568       tree context;
8569
8570       if (in_namespace)
8571         context = in_namespace;
8572       else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
8573         context = current_namespace;
8574       else
8575         context = NULL_TREE;
8576
8577       if (processing_template_decl)
8578         {
8579           /* If we're in a template, we need DECL_LANG_SPECIFIC so that
8580              we can call push_template_decl.  */
8581           push_permanent_obstack ();
8582           decl = build_lang_decl (VAR_DECL, declarator, type);
8583           pop_obstacks ();
8584         }
8585       else
8586         decl = build_decl (VAR_DECL, declarator, type);
8587
8588       if (context)
8589         set_decl_namespace (decl, context, 0);
8590
8591       context = DECL_CONTEXT (decl);
8592       if (declarator && context && current_lang_name != lang_name_c)
8593         DECL_ASSEMBLER_NAME (decl) = build_static_name (context, declarator);
8594     }
8595
8596   if (in_namespace)
8597     set_decl_namespace (decl, in_namespace, 0);
8598
8599   if (RIDBIT_SETP (RID_EXTERN, specbits))
8600     {
8601       DECL_THIS_EXTERN (decl) = 1;
8602       DECL_EXTERNAL (decl) = !initialized;
8603     }
8604
8605   /* In class context, static means one per class,
8606      public access, and static storage.  */
8607   if (DECL_CLASS_SCOPE_P (decl))
8608     {
8609       TREE_PUBLIC (decl) = 1;
8610       TREE_STATIC (decl) = 1;
8611       DECL_EXTERNAL (decl) = 0;
8612     }
8613   /* At top level, either `static' or no s.c. makes a definition
8614      (perhaps tentative), and absence of `static' makes it public.  */
8615   else if (toplevel_bindings_p ())
8616     {
8617       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
8618                             && (DECL_THIS_EXTERN (decl) || ! constp));
8619       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
8620     }
8621   /* Not at top level, only `static' makes a static definition.  */
8622   else
8623     {
8624       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
8625       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
8626     }
8627
8628   if (TREE_PUBLIC (decl))
8629     {
8630       /* [basic.link]: A name with no linkage (notably, the name of a class
8631          or enumeration declared in a local scope) shall not be used to
8632          declare an entity with linkage.
8633
8634          Only check this for public decls for now.  */
8635       tree t = no_linkage_check (TREE_TYPE (decl));
8636       if (t)
8637         {
8638           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8639             /* Ignore for now; `enum { foo } e' is pretty common.  */;
8640           else
8641             cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
8642                         decl, t);
8643         }
8644     }
8645
8646   return decl;
8647 }
8648
8649 /* Create and return a canonical pointer to member function type, for
8650    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
8651
8652 tree
8653 build_ptrmemfunc_type (type)
8654      tree type;
8655 {
8656   tree fields[4];
8657   tree t;
8658   tree u;
8659   tree unqualified_variant = NULL_TREE;
8660
8661   /* If a canonical type already exists for this type, use it.  We use
8662      this method instead of type_hash_canon, because it only does a
8663      simple equality check on the list of field members.  */
8664
8665   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
8666     return t;
8667
8668   /* Make sure that we always have the unqualified pointer-to-member
8669      type first.  */
8670   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
8671     unqualified_variant
8672       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
8673
8674   push_obstacks (TYPE_OBSTACK (type), TYPE_OBSTACK (type));
8675
8676   u = make_lang_type (UNION_TYPE);
8677   SET_IS_AGGR_TYPE (u, 0);
8678   fields[0] = build_lang_decl (FIELD_DECL, pfn_identifier, type);
8679   fields[1] = build_lang_decl (FIELD_DECL, delta2_identifier,
8680                                delta_type_node);
8681   finish_builtin_type (u, "__ptrmemfunc_type", fields, 1, ptr_type_node);
8682   TYPE_NAME (u) = NULL_TREE;
8683
8684   t = make_lang_type (RECORD_TYPE);
8685
8686   /* Let the front-end know this is a pointer to member function...  */
8687   TYPE_PTRMEMFUNC_FLAG (t) = 1;
8688   /* ... and not really an aggregate.  */
8689   SET_IS_AGGR_TYPE (t, 0);
8690
8691   fields[0] = build_lang_decl (FIELD_DECL, delta_identifier,
8692                                delta_type_node);
8693   fields[1] = build_lang_decl (FIELD_DECL, index_identifier,
8694                                delta_type_node);
8695   fields[2] = build_lang_decl (FIELD_DECL, pfn_or_delta2_identifier, u);
8696   finish_builtin_type (t, "__ptrmemfunc_type", fields, 2, ptr_type_node);
8697
8698   pop_obstacks ();
8699
8700   /* Zap out the name so that the back-end will give us the debugging
8701      information for this anonymous RECORD_TYPE.  */
8702   TYPE_NAME (t) = NULL_TREE;
8703
8704   /* If this is not the unqualified form of this pointer-to-member
8705      type, set the TYPE_MAIN_VARIANT for this type to be the
8706      unqualified type.  Since they are actually RECORD_TYPEs that are
8707      not variants of each other, we must do this manually.  */
8708   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
8709     {
8710       t = build_qualified_type (t, CP_TYPE_QUALS (type));
8711       TYPE_MAIN_VARIANT (t) = unqualified_variant;
8712       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
8713       TYPE_NEXT_VARIANT (unqualified_variant) = t;
8714     }
8715
8716   /* Cache this pointer-to-member type so that we can find it again
8717      later.  */
8718   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
8719
8720   /* Seems to be wanted.  */
8721   CLASSTYPE_GOT_SEMICOLON (t) = 1;
8722
8723   return t;
8724 }
8725
8726 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
8727    Check to see that the definition is valid.  Issue appropriate error
8728    messages.  Return 1 if the definition is particularly bad, or 0
8729    otherwise.  */
8730
8731 int
8732 check_static_variable_definition (decl, type)
8733      tree decl;
8734      tree type;
8735 {
8736   /* Motion 10 at San Diego: If a static const integral data member is
8737      initialized with an integral constant expression, the initializer
8738      may appear either in the declaration (within the class), or in
8739      the definition, but not both.  If it appears in the class, the
8740      member is a member constant.  The file-scope definition is always
8741      required.  */
8742   if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
8743     {
8744       cp_error ("in-class initialization of static data member of non-integral type `%T'",
8745                 type);
8746       /* If we just return the declaration, crashes will sometimes
8747          occur.  We therefore return void_type_node, as if this was a
8748          friend declaration, to cause callers to completely ignore
8749          this declaration.  */
8750       return 1;
8751     }
8752   else if (!CP_TYPE_CONST_P (type))
8753     cp_error ("ANSI C++ forbids in-class initialization of non-const static member `%D'",
8754               decl);
8755   else if (pedantic && !INTEGRAL_TYPE_P (type))
8756     cp_pedwarn ("ANSI C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
8757
8758   return 0;
8759 }
8760
8761 /* Given the SIZE (i.e., number of elements) in an array, compute an
8762    appropriate index type for the array.  If non-NULL, NAME is the
8763    name of the thing being declared.  */
8764
8765 static tree
8766 compute_array_index_type (name, size)
8767      tree name;
8768      tree size;
8769 {
8770   tree itype;
8771
8772   /* The size might be the result of a cast. */
8773   STRIP_TYPE_NOPS (size);
8774
8775   /* It might be a const variable or enumeration constant.  */
8776   if (TREE_READONLY_DECL_P (size))
8777     size = decl_constant_value (size);
8778
8779   /* If this involves a template parameter, it will be a constant at
8780      instantiation time, but we don't know what the value is yet.
8781      Even if no template parameters are involved, we may an expression
8782      that is not a constant; we don't even simplify `1 + 2' when
8783      processing a template.  */
8784   if (processing_template_decl)
8785     {
8786       /* Resolve a qualified reference to an enumerator or static
8787          const data member of ours.  */
8788       if (TREE_CODE (size) == SCOPE_REF
8789           && TREE_OPERAND (size, 0) == current_class_type)
8790         {
8791           tree t = lookup_field (current_class_type,
8792                                  TREE_OPERAND (size, 1), 0, 0);
8793           if (t)
8794             size = t;
8795         }
8796
8797       return build_index_type (build_min (MINUS_EXPR, sizetype,
8798                                           size, integer_one_node));
8799     }
8800
8801   /* The array bound must be an integer type.  */
8802   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
8803       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
8804       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
8805     {
8806       cp_error ("size of array `%D' has non-integer type", name);
8807       size = integer_one_node;
8808     }
8809
8810   /* Normally, the array-bound will be a constant.  */
8811   if (TREE_CONSTANT (size))
8812     {
8813       /* Check to see if the array bound overflowed.  Make that an
8814          error, no matter how generous we're being.  */
8815       int old_flag_pedantic_errors = flag_pedantic_errors;
8816       int old_pedantic = pedantic;
8817       pedantic = flag_pedantic_errors = 1;
8818       constant_expression_warning (size);
8819       pedantic = old_pedantic;
8820       flag_pedantic_errors = old_flag_pedantic_errors;
8821
8822       /* An array must have a positive number of elements.  */
8823       if (INT_CST_LT (size, integer_zero_node))
8824         {
8825           cp_error ("size of array `%D' is negative", name);
8826           size = integer_one_node;
8827         }
8828       /* Except that an extension we allow zero-sized arrays.  We
8829          always allow them in system headers because glibc uses
8830          them.  */
8831       else if (integer_zerop (size) && pedantic && !in_system_header)
8832         cp_pedwarn ("ANSI C++ forbids zero-size array `%D'", name);
8833     }
8834
8835   /* Compute the index of the largest element in the array.  It is
8836      one less than the number of elements in the array.  */
8837   itype
8838     = fold (build_binary_op (MINUS_EXPR,
8839                              cp_convert (ssizetype, size),
8840                              cp_convert (ssizetype,
8841                                          integer_one_node)));
8842
8843   /* Check for variable-sized arrays.  We allow such things as an
8844      extension, even though they are not allowed in ANSI/ISO C++.  */
8845   if (!TREE_CONSTANT (itype))
8846     {
8847       if (pedantic)
8848         {
8849           if (name)
8850             cp_pedwarn ("ANSI C++ forbids variable-size array `%D'",
8851                         name);
8852           else
8853             cp_pedwarn ("ANSI C++ forbids variable-size array");
8854         }
8855
8856       /* Create a variable-sized array index type.  */
8857       itype = variable_size (itype);
8858     }
8859   /* Make sure that there was no overflow when creating to a signed
8860      index type.  (For example, on a 32-bit machine, an array with
8861      size 2^32 - 1 is too big.)  */
8862   else if (TREE_OVERFLOW (itype))
8863     {
8864       error ("overflow in array dimension");
8865       TREE_OVERFLOW (itype) = 0;
8866     }
8867
8868   /* Create and return the appropriate index type.  */
8869   return build_index_type (itype);
8870 }
8871
8872 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
8873    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
8874    with this type.  */
8875
8876 static tree
8877 create_array_type_for_decl (name, type, size)
8878      tree name;
8879      tree type;
8880      tree size;
8881 {
8882   tree itype = NULL_TREE;
8883   const char* error_msg;
8884
8885   /* If things have already gone awry, bail now.  */
8886   if (type == error_mark_node || size == error_mark_node)
8887     return error_mark_node;
8888
8889   /* Assume that everything will go OK.  */
8890   error_msg = NULL;
8891
8892   /* There are some types which cannot be array elements.  */
8893   switch (TREE_CODE (type))
8894     {
8895     case VOID_TYPE:
8896       error_msg = "array of void";
8897       break;
8898
8899     case FUNCTION_TYPE:
8900       error_msg = "array of functions";
8901       break;
8902
8903     case REFERENCE_TYPE:
8904       error_msg = "array of references";
8905       break;
8906
8907     case OFFSET_TYPE:
8908       error_msg = "array of data members";
8909       break;
8910
8911     case METHOD_TYPE:
8912       error_msg = "array of function members";
8913       break;
8914
8915     default:
8916       break;
8917     }
8918
8919   /* If something went wrong, issue an error-message and return.  */
8920   if (error_msg)
8921     {
8922       if (name)
8923         cp_error ("declaration of `%D' as %s", name, error_msg);
8924       else
8925         cp_error ("creating %s", error_msg);
8926
8927       return error_mark_node;
8928     }
8929
8930   /* [dcl.array]
8931
8932      The constant expressions that specify the bounds of the arrays
8933      can be omitted only for the first member of the sequence.  */
8934   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
8935     {
8936       cp_error ("declaration of `%D' as multidimensional array",
8937                 name);
8938       cp_error ("must have bounds for all dimensions except the first");
8939
8940       return error_mark_node;
8941     }
8942
8943   /* Figure out the index type for the array.  */
8944   if (size)
8945     itype = compute_array_index_type (name, size);
8946
8947   return build_cplus_array_type (type, itype);
8948 }
8949
8950 /* Given declspecs and a declarator,
8951    determine the name and type of the object declared
8952    and construct a ..._DECL node for it.
8953    (In one case we can return a ..._TYPE node instead.
8954     For invalid input we sometimes return 0.)
8955
8956    DECLSPECS is a chain of tree_list nodes whose value fields
8957     are the storage classes and type specifiers.
8958
8959    DECL_CONTEXT says which syntactic context this declaration is in:
8960      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
8961      FUNCDEF for a function definition.  Like NORMAL but a few different
8962       error messages in each case.  Return value may be zero meaning
8963       this definition is too screwy to try to parse.
8964      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
8965       handle member functions (which have FIELD context).
8966       Return value may be zero meaning this definition is too screwy to
8967       try to parse.
8968      PARM for a parameter declaration (either within a function prototype
8969       or before a function body).  Make a PARM_DECL, or return void_type_node.
8970      CATCHPARM for a parameter declaration before a catch clause.
8971      TYPENAME if for a typename (in a cast or sizeof).
8972       Don't make a DECL node; just return the ..._TYPE node.
8973      FIELD for a struct or union field; make a FIELD_DECL.
8974      BITFIELD for a field with specified width.
8975    INITIALIZED is 1 if the decl has an initializer.
8976
8977    ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
8978    normal attributes in TREE_PURPOSE, or NULL_TREE.
8979
8980    In the TYPENAME case, DECLARATOR is really an absolute declarator.
8981    It may also be so in the PARM case, for a prototype where the
8982    argument type is specified but not the name.
8983
8984    This function is where the complicated C meanings of `static'
8985    and `extern' are interpreted.
8986
8987    For C++, if there is any monkey business to do, the function which
8988    calls this one must do it, i.e., prepending instance variables,
8989    renaming overloaded function names, etc.
8990
8991    Note that for this C++, it is an error to define a method within a class
8992    which does not belong to that class.
8993
8994    Except in the case where SCOPE_REFs are implicitly known (such as
8995    methods within a class being redundantly qualified),
8996    declarations which involve SCOPE_REFs are returned as SCOPE_REFs
8997    (class_name::decl_name).  The caller must also deal with this.
8998
8999    If a constructor or destructor is seen, and the context is FIELD,
9000    then the type gains the attribute TREE_HAS_x.  If such a declaration
9001    is erroneous, NULL_TREE is returned.
9002
9003    QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
9004    function, these are the qualifiers to give to the `this' pointer.
9005
9006    May return void_type_node if the declarator turned out to be a friend.
9007    See grokfield for details.  */
9008
9009 enum return_types { return_normal, return_ctor, return_dtor, return_conversion };
9010
9011 tree
9012 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9013      tree declspecs;
9014      tree declarator;
9015      enum decl_context decl_context;
9016      int initialized;
9017      tree attrlist;
9018 {
9019   RID_BIT_TYPE specbits;
9020   int nclasses = 0;
9021   tree spec;
9022   tree type = NULL_TREE;
9023   int longlong = 0;
9024   int constp;
9025   int restrictp;
9026   int volatilep;
9027   int type_quals;
9028   int virtualp, explicitp, friendp, inlinep, staticp;
9029   int explicit_int = 0;
9030   int explicit_char = 0;
9031   int defaulted_int = 0;
9032   tree typedef_decl = NULL_TREE;
9033   const char *name;
9034   tree typedef_type = NULL_TREE;
9035   int funcdef_flag = 0;
9036   enum tree_code innermost_code = ERROR_MARK;
9037   int bitfield = 0;
9038 #if 0
9039   /* See the code below that used this.  */
9040   tree decl_machine_attr = NULL_TREE;
9041 #endif
9042   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9043      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9044   tree init = NULL_TREE;
9045
9046   /* Keep track of what sort of function is being processed
9047      so that we can warn about default return values, or explicit
9048      return values which do not match prescribed defaults.  */
9049   enum return_types return_type = return_normal;
9050
9051   tree dname = NULL_TREE;
9052   tree ctype = current_class_type;
9053   tree ctor_return_type = NULL_TREE;
9054   enum overload_flags flags = NO_SPECIAL;
9055   tree quals = NULL_TREE;
9056   tree raises = NULL_TREE;
9057   int template_count = 0;
9058   tree in_namespace = NULL_TREE;
9059   tree inner_attrs;
9060   int ignore_attrs;
9061
9062   RIDBIT_RESET_ALL (specbits);
9063   if (decl_context == FUNCDEF)
9064     funcdef_flag = 1, decl_context = NORMAL;
9065   else if (decl_context == MEMFUNCDEF)
9066     funcdef_flag = -1, decl_context = FIELD;
9067   else if (decl_context == BITFIELD)
9068     bitfield = 1, decl_context = FIELD;
9069
9070   /* Look inside a declarator for the name being declared
9071      and get it as a string, for an error message.  */
9072   {
9073     tree *next = &declarator;
9074     register tree decl;
9075     name = NULL;
9076
9077     while (next && *next)
9078       {
9079         decl = *next;
9080         switch (TREE_CODE (decl))
9081           {
9082           case TREE_LIST:
9083             /* For attributes.  */
9084             next = &TREE_VALUE (decl);
9085             break;
9086
9087           case COND_EXPR:
9088             ctype = NULL_TREE;
9089             next = &TREE_OPERAND (decl, 0);
9090             break;
9091
9092           case BIT_NOT_EXPR:    /* For C++ destructors!  */
9093             {
9094               tree name = TREE_OPERAND (decl, 0);
9095               tree rename = NULL_TREE;
9096
9097               my_friendly_assert (flags == NO_SPECIAL, 152);
9098               flags = DTOR_FLAG;
9099               return_type = return_dtor;
9100               if (TREE_CODE (name) == TYPE_DECL)
9101                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9102               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9103               if (ctype == NULL_TREE)
9104                 {
9105                   if (current_class_type == NULL_TREE)
9106                     {
9107                       error ("destructors must be member functions");
9108                       flags = NO_SPECIAL;
9109                     }
9110                   else
9111                     {
9112                       tree t = constructor_name (current_class_name);
9113                       if (t != name)
9114                         rename = t;
9115                     }
9116                 }
9117               else
9118                 {
9119                   tree t = constructor_name (ctype);
9120                   if (t != name)
9121                     rename = t;
9122                 }
9123
9124               if (rename)
9125                 {
9126                   cp_error ("destructor `%T' must match class name `%T'",
9127                             name, rename);
9128                   TREE_OPERAND (decl, 0) = rename;
9129                 }
9130               next = &name;
9131             }
9132             break;
9133
9134           case ADDR_EXPR:       /* C++ reference declaration */
9135             /* Fall through. */
9136           case ARRAY_REF:
9137           case INDIRECT_REF:
9138             ctype = NULL_TREE;
9139             innermost_code = TREE_CODE (decl);
9140             next = &TREE_OPERAND (decl, 0);
9141             break;
9142
9143           case CALL_EXPR:
9144             if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
9145               {
9146                 /* This is actually a variable declaration using
9147                    constructor syntax.  We need to call start_decl and
9148                    cp_finish_decl so we can get the variable
9149                    initialized...  */
9150
9151                 tree attributes, prefix_attributes;
9152
9153                 *next = TREE_OPERAND (decl, 0);
9154                 init = CALL_DECLARATOR_PARMS (decl);
9155
9156                 if (attrlist)
9157                   {
9158                     attributes = TREE_PURPOSE (attrlist);
9159                     prefix_attributes = TREE_VALUE (attrlist);
9160                   }
9161                 else
9162                   {
9163                     attributes = NULL_TREE;
9164                     prefix_attributes = NULL_TREE;
9165                   }
9166
9167                 decl = start_decl (declarator, declspecs, 1,
9168                                    attributes, prefix_attributes);
9169                 if (decl)
9170                   {
9171                     /* Look for __unused__ attribute */
9172                     if (TREE_USED (TREE_TYPE (decl)))
9173                       TREE_USED (decl) = 1;
9174                     finish_decl (decl, init, NULL_TREE);
9175                   }
9176                 else
9177                   cp_error ("invalid declarator");
9178                 return 0;
9179               }
9180             innermost_code = TREE_CODE (decl);
9181             if (decl_context == FIELD && ctype == NULL_TREE)
9182               ctype = current_class_type;
9183             if (ctype
9184                 && TREE_OPERAND (decl, 0)
9185                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9186                     && ((DECL_NAME (TREE_OPERAND (decl, 0))
9187                          == constructor_name_full (ctype))
9188                         || (DECL_NAME (TREE_OPERAND (decl, 0))
9189                             == constructor_name (ctype)))))
9190               TREE_OPERAND (decl, 0) = constructor_name (ctype);
9191             next = &TREE_OPERAND (decl, 0);
9192             decl = *next;
9193             if (ctype != NULL_TREE
9194                 && decl != NULL_TREE && flags != DTOR_FLAG
9195                 && decl == constructor_name (ctype))
9196               {
9197                 return_type = return_ctor;
9198                 ctor_return_type = ctype;
9199               }
9200             ctype = NULL_TREE;
9201             break;
9202
9203           case TEMPLATE_ID_EXPR:
9204               {
9205                 tree fns = TREE_OPERAND (decl, 0);
9206
9207                 if (TREE_CODE (fns) == LOOKUP_EXPR)
9208                   fns = TREE_OPERAND (fns, 0);
9209
9210                 dname = fns;
9211                 if (TREE_CODE (dname) == COMPONENT_REF)
9212                   dname = TREE_OPERAND (dname, 1);
9213                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9214                   {
9215                     my_friendly_assert (is_overloaded_fn (dname),
9216                                         19990331);
9217                     dname = DECL_NAME (get_first_fn (dname));
9218                   }
9219               }
9220           /* Fall through. */
9221
9222           case IDENTIFIER_NODE:
9223             if (TREE_CODE (decl) == IDENTIFIER_NODE)
9224               dname = decl;
9225
9226             next = 0;
9227
9228             if (is_rid (dname))
9229               {
9230                 cp_error ("declarator-id missing; using reserved word `%D'",
9231                           dname);
9232                 name = IDENTIFIER_POINTER (dname);
9233               }
9234             if (! IDENTIFIER_OPNAME_P (dname)
9235                 /* GNU/Linux headers use '__op'.  Arrgh.  */
9236                 || (IDENTIFIER_TYPENAME_P (dname) && ! TREE_TYPE (dname)))
9237               name = IDENTIFIER_POINTER (dname);
9238             else
9239               {
9240                 if (IDENTIFIER_TYPENAME_P (dname))
9241                   {
9242                     my_friendly_assert (flags == NO_SPECIAL, 154);
9243                     flags = TYPENAME_FLAG;
9244                     ctor_return_type = TREE_TYPE (dname);
9245                     return_type = return_conversion;
9246                   }
9247                 name = operator_name_string (dname);
9248               }
9249             break;
9250
9251             /* C++ extension */
9252           case SCOPE_REF:
9253             {
9254               /* Perform error checking, and decide on a ctype.  */
9255               tree cname = TREE_OPERAND (decl, 0);
9256               if (cname == NULL_TREE)
9257                 ctype = NULL_TREE;
9258               else if (TREE_CODE (cname) == NAMESPACE_DECL)
9259                 {
9260                   ctype = NULL_TREE;
9261                   in_namespace = TREE_OPERAND (decl, 0);
9262                   TREE_OPERAND (decl, 0) = NULL_TREE;
9263                 }
9264               else if (! is_aggr_type (cname, 1))
9265                 TREE_OPERAND (decl, 0) = NULL_TREE;
9266               /* Must test TREE_OPERAND (decl, 1), in case user gives
9267                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
9268               else if (TREE_OPERAND (decl, 1)
9269                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9270                 ctype = cname;
9271               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9272                        || TREE_CODE (cname) == TEMPLATE_TEMPLATE_PARM)
9273                 {
9274                   cp_error ("`%T::%D' is not a valid declarator", cname,
9275                             TREE_OPERAND (decl, 1));
9276                   cp_error ("  perhaps you want `typename %T::%D' to make it a type",
9277                             cname, TREE_OPERAND (decl, 1));
9278                   return void_type_node;
9279                 }
9280               else if (ctype == NULL_TREE)
9281                 ctype = cname;
9282               else if (TREE_COMPLEXITY (decl) == current_class_depth)
9283                 TREE_OPERAND (decl, 0) = ctype;
9284               else
9285                 {
9286                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9287                     {
9288                       cp_error ("type `%T' is not derived from type `%T'",
9289                                 cname, ctype);
9290                       TREE_OPERAND (decl, 0) = NULL_TREE;
9291                     }
9292                   else
9293                     ctype = cname;
9294                 }
9295
9296               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
9297                   && ((DECL_NAME (TREE_OPERAND (decl, 1))
9298                        == constructor_name_full (ctype))
9299                       || (DECL_NAME (TREE_OPERAND (decl, 1))
9300                           == constructor_name (ctype))))
9301                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
9302               next = &TREE_OPERAND (decl, 1);
9303               decl = *next;
9304               if (ctype)
9305                 {
9306                   if (TREE_CODE (decl) == IDENTIFIER_NODE
9307                       && constructor_name (ctype) == decl)
9308                     {
9309                       return_type = return_ctor;
9310                       ctor_return_type = ctype;
9311                     }
9312                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
9313                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
9314                            && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
9315                                || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
9316                     {
9317                       return_type = return_dtor;
9318                       ctor_return_type = ctype;
9319                       flags = DTOR_FLAG;
9320                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
9321                       next = &TREE_OPERAND (decl, 0);
9322                     }
9323                 }
9324             }
9325             break;
9326
9327           case ERROR_MARK:
9328             next = 0;
9329             break;
9330
9331           case TYPE_DECL:
9332             /* Parse error puts this typespec where
9333                a declarator should go.  */
9334             cp_error ("`%T' specified as declarator-id", DECL_NAME (decl));
9335             if (TREE_TYPE (decl) == current_class_type)
9336               cp_error ("  perhaps you want `%T' for a constructor",
9337                         current_class_name);
9338             dname = DECL_NAME (decl);
9339             name = IDENTIFIER_POINTER (dname);
9340
9341             /* Avoid giving two errors for this.  */
9342             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
9343
9344             declspecs = temp_tree_cons (NULL_TREE, integer_type_node,
9345                                         declspecs);
9346             *next = dname;
9347             next = 0;
9348             break;
9349
9350           default:
9351             cp_compiler_error ("`%D' as declarator", decl);
9352             return 0; /* We used to do a 155 abort here.  */
9353           }
9354       }
9355   }
9356
9357   /* A function definition's declarator must have the form of
9358      a function declarator.  */
9359
9360   if (funcdef_flag && innermost_code != CALL_EXPR)
9361     return 0;
9362
9363   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
9364       && innermost_code != CALL_EXPR
9365       && ! (ctype && declspecs == NULL_TREE))
9366     {
9367       cp_error ("declaration of `%D' as non-function", dname);
9368       return void_type_node;
9369     }
9370
9371   /* Anything declared one level down from the top level
9372      must be one of the parameters of a function
9373      (because the body is at least two levels down).  */
9374
9375   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9376      by not allowing C++ class definitions to specify their parameters
9377      with xdecls (must be spec.d in the parmlist).
9378
9379      Since we now wait to push a class scope until we are sure that
9380      we are in a legitimate method context, we must set oldcname
9381      explicitly (since current_class_name is not yet alive).
9382
9383      We also want to avoid calling this a PARM if it is in a namespace.  */
9384
9385   if (decl_context == NORMAL && !toplevel_bindings_p ())
9386     {
9387       struct binding_level *b = current_binding_level;
9388       current_binding_level = b->level_chain;
9389       if (current_binding_level != 0 && toplevel_bindings_p ())
9390         decl_context = PARM;
9391       current_binding_level = b;
9392     }
9393
9394   if (name == NULL)
9395     name = decl_context == PARM ? "parameter" : "type name";
9396
9397   /* Look through the decl specs and record which ones appear.
9398      Some typespecs are defined as built-in typenames.
9399      Others, the ones that are modifiers of other types,
9400      are represented by bits in SPECBITS: set the bits for
9401      the modifiers that appear.  Storage class keywords are also in SPECBITS.
9402
9403      If there is a typedef name or a type, store the type in TYPE.
9404      This includes builtin typedefs such as `int'.
9405
9406      Set EXPLICIT_INT if the type is `int' or `char' and did not
9407      come from a user typedef.
9408
9409      Set LONGLONG if `long' is mentioned twice.
9410
9411      For C++, constructors and destructors have their own fast treatment.  */
9412
9413   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
9414     {
9415       register int i;
9416       register tree id;
9417
9418       /* Certain parse errors slip through.  For example,
9419          `int class;' is not caught by the parser. Try
9420          weakly to recover here.  */
9421       if (TREE_CODE (spec) != TREE_LIST)
9422         return 0;
9423
9424       id = TREE_VALUE (spec);
9425
9426       if (TREE_CODE (id) == IDENTIFIER_NODE)
9427         {
9428           if (id == ridpointers[(int) RID_INT]
9429               || id == ridpointers[(int) RID_CHAR]
9430               || id == ridpointers[(int) RID_BOOL]
9431               || id == ridpointers[(int) RID_WCHAR])
9432             {
9433               if (type)
9434                 {
9435                   if (id == ridpointers[(int) RID_BOOL])
9436                     error ("`bool' is now a keyword");
9437                   else
9438                     cp_error ("extraneous `%T' ignored", id);
9439                 }
9440               else
9441                 {
9442                   if (id == ridpointers[(int) RID_INT])
9443                     explicit_int = 1;
9444                   else if (id == ridpointers[(int) RID_CHAR])
9445                     explicit_char = 1;
9446                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
9447                 }
9448               goto found;
9449             }
9450           /* C++ aggregate types.  */
9451           if (IDENTIFIER_HAS_TYPE_VALUE (id))
9452             {
9453               if (type)
9454                 cp_error ("multiple declarations `%T' and `%T'", type, id);
9455               else
9456                 type = IDENTIFIER_TYPE_VALUE (id);
9457               goto found;
9458             }
9459
9460           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
9461             {
9462               if (ridpointers[i] == id)
9463                 {
9464                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
9465                     {
9466                       if (pedantic && ! in_system_header && warn_long_long)
9467                         pedwarn ("ANSI C++ does not support `long long'");
9468                       if (longlong)
9469                         error ("`long long long' is too long for GCC");
9470                       else
9471                         longlong = 1;
9472                     }
9473                   else if (RIDBIT_SETP (i, specbits))
9474                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
9475                   RIDBIT_SET (i, specbits);
9476                   goto found;
9477                 }
9478             }
9479         }
9480       /* C++ aggregate types.  */
9481       else if (TREE_CODE (id) == TYPE_DECL || TREE_CODE (id) == TEMPLATE_DECL)
9482         {
9483           if (type)
9484             cp_error ("multiple declarations `%T' and `%T'", type,
9485                       TREE_TYPE (id));
9486           else
9487             {
9488               type = TREE_TYPE (id);
9489               TREE_VALUE (spec) = type;
9490             }
9491           goto found;
9492         }
9493       if (type)
9494         error ("two or more data types in declaration of `%s'", name);
9495       else if (TREE_CODE (id) == IDENTIFIER_NODE)
9496         {
9497           register tree t = lookup_name (id, 1);
9498           if (!t || TREE_CODE (t) != TYPE_DECL)
9499             error ("`%s' fails to be a typedef or built in type",
9500                    IDENTIFIER_POINTER (id));
9501           else
9502             {
9503               type = TREE_TYPE (t);
9504 #if 0
9505               /* See the code below that used this.  */
9506               decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
9507 #endif
9508               typedef_decl = t;
9509             }
9510         }
9511       else if (id != error_mark_node)
9512         /* Can't change CLASS nodes into RECORD nodes here!  */
9513         type = id;
9514
9515     found: ;
9516     }
9517
9518   typedef_type = type;
9519
9520   /* No type at all: default to `int', and set DEFAULTED_INT
9521      because it was not a user-defined typedef.  */
9522
9523   if (type == NULL_TREE
9524       && (RIDBIT_SETP (RID_SIGNED, specbits)
9525           || RIDBIT_SETP (RID_UNSIGNED, specbits)
9526           || RIDBIT_SETP (RID_LONG, specbits)
9527           || RIDBIT_SETP (RID_SHORT, specbits)))
9528     {
9529       /* These imply 'int'.  */
9530       type = integer_type_node;
9531       defaulted_int = 1;
9532     }
9533
9534   if (type == NULL_TREE)
9535     {
9536       explicit_int = -1;
9537       if (return_type == return_dtor)
9538         type = void_type_node;
9539       else if (return_type == return_ctor)
9540         type = build_pointer_type (ctor_return_type);
9541       else if (return_type == return_conversion)
9542         type = ctor_return_type;
9543       else
9544         {
9545           /* We handle `main' specially here, because 'main () { }' is so
9546              common.  With no options, it is allowed.  With -Wreturn-type,
9547              it is a warning.  It is only an error with -pedantic-errors.  */
9548           int is_main = (funcdef_flag
9549                          && MAIN_NAME_P (dname)
9550                          && ctype == NULL_TREE
9551                          && in_namespace == NULL_TREE
9552                          && current_namespace == global_namespace);
9553
9554           if (in_system_header || flag_ms_extensions)
9555             /* Allow it, sigh.  */;
9556           else if (pedantic || ! is_main)
9557             cp_pedwarn ("ANSI C++ forbids declaration of `%s' with no type",
9558                         name);
9559           else if (warn_return_type)
9560             cp_warning ("ANSI C++ forbids declaration of `%s' with no type",
9561                         name);
9562
9563           type = integer_type_node;
9564         }
9565     }
9566   else if (return_type == return_dtor)
9567     {
9568       error ("return type specification for destructor invalid");
9569       type = void_type_node;
9570     }
9571   else if (return_type == return_ctor)
9572     {
9573       error ("return type specification for constructor invalid");
9574       type = build_pointer_type (ctor_return_type);
9575     }
9576   else if (return_type == return_conversion)
9577     {
9578       if (!same_type_p (type, ctor_return_type))
9579         cp_error ("operator `%T' declared to return `%T'",
9580                   ctor_return_type, type);
9581       else
9582         cp_pedwarn ("return type specified for `operator %T'",
9583                     ctor_return_type);
9584
9585       type = ctor_return_type;
9586     }
9587
9588   ctype = NULL_TREE;
9589
9590   /* Now process the modifiers that were specified
9591      and check for invalid combinations.  */
9592
9593   /* Long double is a special combination.  */
9594
9595   if (RIDBIT_SETP (RID_LONG, specbits)
9596       && TYPE_MAIN_VARIANT (type) == double_type_node)
9597     {
9598       RIDBIT_RESET (RID_LONG, specbits);
9599       type = build_qualified_type (long_double_type_node,
9600                                    CP_TYPE_QUALS (type));
9601     }
9602
9603   /* Check all other uses of type modifiers.  */
9604
9605   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
9606       || RIDBIT_SETP (RID_SIGNED, specbits)
9607       || RIDBIT_SETP (RID_LONG, specbits)
9608       || RIDBIT_SETP (RID_SHORT, specbits))
9609     {
9610       int ok = 0;
9611
9612       if (TREE_CODE (type) == REAL_TYPE)
9613         error ("short, signed or unsigned invalid for `%s'", name);
9614       else if (TREE_CODE (type) != INTEGER_TYPE)
9615         error ("long, short, signed or unsigned invalid for `%s'", name);
9616       else if (RIDBIT_SETP (RID_LONG, specbits)
9617                && RIDBIT_SETP (RID_SHORT, specbits))
9618         error ("long and short specified together for `%s'", name);
9619       else if ((RIDBIT_SETP (RID_LONG, specbits)
9620                 || RIDBIT_SETP (RID_SHORT, specbits))
9621                && explicit_char)
9622         error ("long or short specified with char for `%s'", name);
9623       else if ((RIDBIT_SETP (RID_LONG, specbits)
9624                 || RIDBIT_SETP (RID_SHORT, specbits))
9625                && TREE_CODE (type) == REAL_TYPE)
9626         error ("long or short specified with floating type for `%s'", name);
9627       else if (RIDBIT_SETP (RID_SIGNED, specbits)
9628                && RIDBIT_SETP (RID_UNSIGNED, specbits))
9629         error ("signed and unsigned given together for `%s'", name);
9630       else
9631         {
9632           ok = 1;
9633           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
9634             {
9635               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
9636                        name);
9637               if (flag_pedantic_errors)
9638                 ok = 0;
9639             }
9640         }
9641
9642       /* Discard the type modifiers if they are invalid.  */
9643       if (! ok)
9644         {
9645           RIDBIT_RESET (RID_UNSIGNED, specbits);
9646           RIDBIT_RESET (RID_SIGNED, specbits);
9647           RIDBIT_RESET (RID_LONG, specbits);
9648           RIDBIT_RESET (RID_SHORT, specbits);
9649           longlong = 0;
9650         }
9651     }
9652
9653   if (RIDBIT_SETP (RID_COMPLEX, specbits)
9654       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
9655     {
9656       error ("complex invalid for `%s'", name);
9657       RIDBIT_RESET (RID_COMPLEX, specbits);
9658     }
9659
9660   /* Decide whether an integer type is signed or not.
9661      Optionally treat bitfields as signed by default.  */
9662   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
9663       /* [class.bit]
9664
9665          It is implementation-defined whether a plain (neither
9666          explicitly signed or unsigned) char, short, int, or long
9667          bit-field is signed or unsigned.
9668
9669          Naturally, we extend this to long long as well.  Note that
9670          this does not include wchar_t.  */
9671       || (bitfield && !flag_signed_bitfields
9672           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
9673           /* A typedef for plain `int' without `signed' can be
9674              controlled just like plain `int', but a typedef for
9675              `signed int' cannot be so controlled.  */
9676           && !(typedef_decl
9677                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
9678           && (TREE_CODE (type) == INTEGER_TYPE
9679               || TREE_CODE (type) == CHAR_TYPE)
9680           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
9681     {
9682       if (longlong)
9683         type = long_long_unsigned_type_node;
9684       else if (RIDBIT_SETP (RID_LONG, specbits))
9685         type = long_unsigned_type_node;
9686       else if (RIDBIT_SETP (RID_SHORT, specbits))
9687         type = short_unsigned_type_node;
9688       else if (type == char_type_node)
9689         type = unsigned_char_type_node;
9690       else if (typedef_decl)
9691         type = unsigned_type (type);
9692       else
9693         type = unsigned_type_node;
9694     }
9695   else if (RIDBIT_SETP (RID_SIGNED, specbits)
9696            && type == char_type_node)
9697     type = signed_char_type_node;
9698   else if (longlong)
9699     type = long_long_integer_type_node;
9700   else if (RIDBIT_SETP (RID_LONG, specbits))
9701     type = long_integer_type_node;
9702   else if (RIDBIT_SETP (RID_SHORT, specbits))
9703     type = short_integer_type_node;
9704
9705   if (RIDBIT_SETP (RID_COMPLEX, specbits))
9706     {
9707       /* If we just have "complex", it is equivalent to
9708          "complex double", but if any modifiers at all are specified it is
9709          the complex form of TYPE.  E.g, "complex short" is
9710          "complex short int".  */
9711
9712       if (defaulted_int && ! longlong
9713           && ! (RIDBIT_SETP (RID_LONG, specbits)
9714                 || RIDBIT_SETP (RID_SHORT, specbits)
9715                 || RIDBIT_SETP (RID_SIGNED, specbits)
9716                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
9717         type = complex_double_type_node;
9718       else if (type == integer_type_node)
9719         type = complex_integer_type_node;
9720       else if (type == float_type_node)
9721         type = complex_float_type_node;
9722       else if (type == double_type_node)
9723         type = complex_double_type_node;
9724       else if (type == long_double_type_node)
9725         type = complex_long_double_type_node;
9726       else
9727         type = build_complex_type (type);
9728     }
9729
9730   if (return_type == return_conversion
9731       && (RIDBIT_SETP (RID_CONST, specbits)
9732           || RIDBIT_SETP (RID_VOLATILE, specbits)
9733           || RIDBIT_SETP (RID_RESTRICT, specbits)))
9734     cp_error ("qualifiers are not allowed on declaration of `operator %T'",
9735               ctor_return_type);
9736
9737   /* Set CONSTP if this declaration is `const', whether by
9738      explicit specification or via a typedef.
9739      Likewise for VOLATILEP.  */
9740
9741   constp = !! RIDBIT_SETP (RID_CONST, specbits) + CP_TYPE_CONST_P (type);
9742   restrictp =
9743     !! RIDBIT_SETP (RID_RESTRICT, specbits) + CP_TYPE_RESTRICT_P (type);
9744   volatilep =
9745     !! RIDBIT_SETP (RID_VOLATILE, specbits) + CP_TYPE_VOLATILE_P (type);
9746   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
9747                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
9748                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
9749   type = cp_build_qualified_type (type, type_quals);
9750   staticp = 0;
9751   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
9752   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
9753   RIDBIT_RESET (RID_VIRTUAL, specbits);
9754   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
9755   RIDBIT_RESET (RID_EXPLICIT, specbits);
9756
9757   if (RIDBIT_SETP (RID_STATIC, specbits))
9758     staticp = 1 + (decl_context == FIELD);
9759
9760   if (virtualp && staticp == 2)
9761     {
9762       cp_error ("member `%D' cannot be declared both virtual and static",
9763                 dname);
9764       staticp = 0;
9765     }
9766   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
9767   RIDBIT_RESET (RID_FRIEND, specbits);
9768
9769   /* Warn if two storage classes are given. Default to `auto'.  */
9770
9771   if (RIDBIT_ANY_SET (specbits))
9772     {
9773       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
9774       if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
9775       if (decl_context == PARM && nclasses > 0)
9776         error ("storage class specifiers invalid in parameter declarations");
9777       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
9778         {
9779           if (decl_context == PARM)
9780             error ("typedef declaration invalid in parameter declaration");
9781           nclasses++;
9782         }
9783       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
9784       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
9785     }
9786
9787   /* Give error if `virtual' is used outside of class declaration.  */
9788   if (virtualp
9789       && (current_class_name == NULL_TREE || decl_context != FIELD))
9790     {
9791       error ("virtual outside class declaration");
9792       virtualp = 0;
9793     }
9794
9795   /* Static anonymous unions are dealt with here.  */
9796   if (staticp && decl_context == TYPENAME
9797       && TREE_CODE (declspecs) == TREE_LIST
9798       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
9799     decl_context = FIELD;
9800
9801   /* Warn about storage classes that are invalid for certain
9802      kinds of declarations (parameters, typenames, etc.).  */
9803
9804   if (nclasses > 1)
9805     error ("multiple storage classes in declaration of `%s'", name);
9806   else if (decl_context != NORMAL && nclasses > 0)
9807     {
9808       if ((decl_context == PARM || decl_context == CATCHPARM)
9809           && (RIDBIT_SETP (RID_REGISTER, specbits)
9810               || RIDBIT_SETP (RID_AUTO, specbits)))
9811         ;
9812       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
9813         ;
9814       else if (decl_context == FIELD
9815                /* C++ allows static class elements  */
9816                && RIDBIT_SETP (RID_STATIC, specbits))
9817         /* C++ also allows inlines and signed and unsigned elements,
9818            but in those cases we don't come in here.  */
9819         ;
9820       else
9821         {
9822           if (decl_context == FIELD)
9823             {
9824               tree tmp = NULL_TREE;
9825               register int op = 0;
9826
9827               if (declarator)
9828                 {
9829                   /* Avoid trying to get an operand off an identifier node.  */
9830                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
9831                     tmp = declarator;
9832                   else
9833                     tmp = TREE_OPERAND (declarator, 0);
9834                   op = IDENTIFIER_OPNAME_P (tmp);
9835                 }
9836               error ("storage class specified for %s `%s'",
9837                      op ? "member operator" : "field",
9838                      op ? operator_name_string (tmp) : name);
9839             }
9840           else
9841             error (((decl_context == PARM || decl_context == CATCHPARM)
9842                     ? "storage class specified for parameter `%s'"
9843                     : "storage class specified for typename"), name);
9844           RIDBIT_RESET (RID_REGISTER, specbits);
9845           RIDBIT_RESET (RID_AUTO, specbits);
9846           RIDBIT_RESET (RID_EXTERN, specbits);
9847         }
9848     }
9849   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
9850     {
9851       if (toplevel_bindings_p ())
9852         {
9853           /* It's common practice (and completely valid) to have a const
9854              be initialized and declared extern.  */
9855           if (!(type_quals & TYPE_QUAL_CONST))
9856             warning ("`%s' initialized and declared `extern'", name);
9857         }
9858       else
9859         error ("`%s' has both `extern' and initializer", name);
9860     }
9861   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
9862            && ! toplevel_bindings_p ())
9863     error ("nested function `%s' declared `extern'", name);
9864   else if (toplevel_bindings_p ())
9865     {
9866       if (RIDBIT_SETP (RID_AUTO, specbits))
9867         error ("top-level declaration of `%s' specifies `auto'", name);
9868     }
9869
9870   if (nclasses > 0 && friendp)
9871     error ("storage class specifiers invalid in friend function declarations");
9872
9873   /* Now figure out the structure of the declarator proper.
9874      Descend through it, creating more complex types, until we reach
9875      the declared identifier (or NULL_TREE, in an absolute declarator).  */
9876
9877   inner_attrs = NULL_TREE;
9878   ignore_attrs = 0;
9879
9880   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
9881          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
9882     {
9883       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
9884          an INDIRECT_REF (for *...),
9885          a CALL_EXPR (for ...(...)),
9886          an identifier (for the name being declared)
9887          or a null pointer (for the place in an absolute declarator
9888          where the name was omitted).
9889          For the last two cases, we have just exited the loop.
9890
9891          For C++ it could also be
9892          a SCOPE_REF (for class :: ...).  In this case, we have converted
9893          sensible names to types, and those are the values we use to
9894          qualify the member name.
9895          an ADDR_EXPR (for &...),
9896          a BIT_NOT_EXPR (for destructors)
9897
9898          At this point, TYPE is the type of elements of an array,
9899          or for a function to return, or for a pointer to point to.
9900          After this sequence of ifs, TYPE is the type of the
9901          array or function or pointer, and DECLARATOR has had its
9902          outermost layer removed.  */
9903
9904       if (type == error_mark_node)
9905         {
9906           if (TREE_CODE (declarator) == SCOPE_REF)
9907             declarator = TREE_OPERAND (declarator, 1);
9908           else
9909             declarator = TREE_OPERAND (declarator, 0);
9910           continue;
9911         }
9912       if (quals != NULL_TREE
9913           && (declarator == NULL_TREE
9914               || TREE_CODE (declarator) != SCOPE_REF))
9915         {
9916           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
9917             ctype = TYPE_METHOD_BASETYPE (type);
9918           if (ctype != NULL_TREE)
9919             {
9920               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
9921               ctype = grok_method_quals (ctype, dummy, quals);
9922               type = TREE_TYPE (dummy);
9923               quals = NULL_TREE;
9924             }
9925         }
9926
9927       /* See the comment for the TREE_LIST case, below.  */
9928       if (ignore_attrs)
9929         ignore_attrs = 0;
9930       else if (inner_attrs)
9931         {
9932           decl_attributes (type, inner_attrs, NULL_TREE);
9933           inner_attrs = NULL_TREE;
9934         }
9935
9936       switch (TREE_CODE (declarator))
9937         {
9938         case TREE_LIST:
9939           {
9940             /* We encode a declarator with embedded attributes using
9941                a TREE_LIST.  The attributes apply to the declarator
9942                directly inside them, so we have to skip an iteration
9943                before applying them to the type.  If the declarator just
9944                inside is the declarator-id, we apply the attrs to the
9945                decl itself.  */
9946             inner_attrs = TREE_PURPOSE (declarator);
9947             ignore_attrs = 1;
9948             declarator = TREE_VALUE (declarator);
9949           }
9950           break;
9951
9952         case ARRAY_REF:
9953           {
9954             register tree size;
9955
9956             size = TREE_OPERAND (declarator, 1);
9957
9958             /* VC++ spells a zero-sized array with [].  */
9959             if (size == NULL_TREE && decl_context == FIELD && ! staticp
9960                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
9961               size = integer_zero_node;
9962
9963             declarator = TREE_OPERAND (declarator, 0);
9964
9965             type = create_array_type_for_decl (dname, type, size);
9966             ctype = NULL_TREE;
9967           }
9968           break;
9969
9970         case CALL_EXPR:
9971           {
9972             tree arg_types;
9973             int funcdecl_p;
9974             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
9975             tree inner_decl = TREE_OPERAND (declarator, 0);
9976
9977             /* Declaring a function type.
9978                Make sure we have a valid type for the function to return.  */
9979
9980             /* We now know that the TYPE_QUALS don't apply to the
9981                decl, but to its return type.  */
9982             type_quals = TYPE_UNQUALIFIED;
9983
9984             /* Warn about some types functions can't return.  */
9985
9986             if (TREE_CODE (type) == FUNCTION_TYPE)
9987               {
9988                 error ("`%s' declared as function returning a function", name);
9989                 type = integer_type_node;
9990               }
9991             if (TREE_CODE (type) == ARRAY_TYPE)
9992               {
9993                 error ("`%s' declared as function returning an array", name);
9994                 type = integer_type_node;
9995               }
9996
9997             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
9998               inner_decl = TREE_OPERAND (inner_decl, 1);
9999
10000             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10001               inner_decl = dname;
10002
10003             /* Pick up type qualifiers which should be applied to `this'.  */
10004             quals = CALL_DECLARATOR_QUALS (declarator);
10005
10006             /* Pick up the exception specifications.  */
10007             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10008
10009             /* Say it's a definition only for the CALL_EXPR
10010                closest to the identifier.  */
10011             funcdecl_p
10012               = inner_decl
10013               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10014                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10015                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10016
10017             if (ctype == NULL_TREE
10018                 && decl_context == FIELD
10019                 && funcdecl_p
10020                 && (friendp == 0 || dname == current_class_name))
10021               ctype = current_class_type;
10022
10023             if (ctype && return_type == return_conversion)
10024               TYPE_HAS_CONVERSION (ctype) = 1;
10025             if (ctype && constructor_name (ctype) == dname)
10026               {
10027                 /* We are within a class's scope. If our declarator name
10028                    is the same as the class name, and we are defining
10029                    a function, then it is a constructor/destructor, and
10030                    therefore returns a void type.  */
10031
10032                 if (flags == DTOR_FLAG)
10033                   {
10034                     /* ANSI C++ June 5 1992 WP 12.4.1.  A destructor may
10035                        not be declared const or volatile.  A destructor
10036                        may not be static.  */
10037                     if (staticp == 2)
10038                       error ("destructor cannot be static member function");
10039                     if (quals)
10040                       {
10041                         cp_error ("destructors may not be `%s'",
10042                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10043                         quals = NULL_TREE;
10044                       }
10045                     if (decl_context == FIELD)
10046                       {
10047                         if (! member_function_or_else (ctype, current_class_type,
10048                                                        "destructor for alien class `%s' cannot be a member"))
10049                           return void_type_node;
10050                       }
10051                   }
10052                 else            /* It's a constructor.  */
10053                   {
10054                     if (explicitp == 1)
10055                       explicitp = 2;
10056                     /* ANSI C++ June 5 1992 WP 12.1.2.  A constructor may
10057                        not be declared const or volatile.  A constructor may
10058                        not be virtual.  A constructor may not be static.  */
10059                     if (staticp == 2)
10060                       error ("constructor cannot be static member function");
10061                     if (virtualp)
10062                       {
10063                         pedwarn ("constructors cannot be declared virtual");
10064                         virtualp = 0;
10065                       }
10066                     if (quals)
10067                       {
10068                         cp_error ("constructors may not be `%s'",
10069                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10070                         quals = NULL_TREE;
10071                       }
10072                     {
10073                       RID_BIT_TYPE tmp_bits;
10074                       bcopy ((void*)&specbits, (void*)&tmp_bits, sizeof (RID_BIT_TYPE));
10075                       RIDBIT_RESET (RID_INLINE, tmp_bits);
10076                       RIDBIT_RESET (RID_STATIC, tmp_bits);
10077                       if (RIDBIT_ANY_SET (tmp_bits))
10078                         error ("return value type specifier for constructor ignored");
10079                     }
10080                     type = build_pointer_type (ctype);
10081                     if (decl_context == FIELD)
10082                       {
10083                         if (! member_function_or_else (ctype, current_class_type,
10084                                                        "constructor for alien class `%s' cannot be member"))
10085                           return void_type_node;
10086                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10087                         if (return_type != return_ctor)
10088                           return NULL_TREE;
10089                       }
10090                   }
10091                 if (decl_context == FIELD)
10092                   staticp = 0;
10093               }
10094             else if (friendp)
10095               {
10096                 if (initialized)
10097                   error ("can't initialize friend function `%s'", name);
10098                 if (virtualp)
10099                   {
10100                     /* Cannot be both friend and virtual.  */
10101                     error ("virtual functions cannot be friends");
10102                     RIDBIT_RESET (RID_FRIEND, specbits);
10103                     friendp = 0;
10104                   }
10105                 if (decl_context == NORMAL)
10106                   error ("friend declaration not in class definition");
10107                 if (current_function_decl && funcdef_flag)
10108                   cp_error ("can't define friend function `%s' in a local class definition",
10109                             name);
10110               }
10111
10112             /* Construct the function type and go to the next
10113                inner layer of declarator.  */
10114
10115             declarator = TREE_OPERAND (declarator, 0);
10116
10117             /* FIXME: This is where default args should be fully
10118                processed.  */
10119
10120             arg_types = grokparms (inner_parms, funcdecl_p ? funcdef_flag : 0);
10121
10122             if (declarator && flags == DTOR_FLAG)
10123               {
10124                 /* A destructor declared in the body of a class will
10125                    be represented as a BIT_NOT_EXPR.  But, we just
10126                    want the underlying IDENTIFIER.  */
10127                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10128                   declarator = TREE_OPERAND (declarator, 0);
10129
10130                 if (strict_prototype == 0 && arg_types == NULL_TREE)
10131                   arg_types = void_list_node;
10132                 else if (arg_types == NULL_TREE
10133                          || arg_types != void_list_node)
10134                   {
10135                     cp_error ("destructors may not have parameters");
10136                     arg_types = void_list_node;
10137                     last_function_parms = NULL_TREE;
10138                   }
10139               }
10140
10141             /* ANSI says that `const int foo ();'
10142                does not make the function foo const.  */
10143             type = build_function_type (type, arg_types);
10144
10145             {
10146               tree t;
10147               for (t = arg_types; t; t = TREE_CHAIN (t))
10148                 if (TREE_PURPOSE (t)
10149                     && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10150                   {
10151                     add_defarg_fn (type);
10152                     break;
10153                   }
10154             }
10155           }
10156           break;
10157
10158         case ADDR_EXPR:
10159         case INDIRECT_REF:
10160           /* Filter out pointers-to-references and references-to-references.
10161              We can get these if a TYPE_DECL is used.  */
10162
10163           if (TREE_CODE (type) == REFERENCE_TYPE)
10164             {
10165               error ("cannot declare %s to references",
10166                      TREE_CODE (declarator) == ADDR_EXPR
10167                      ? "references" : "pointers");
10168               declarator = TREE_OPERAND (declarator, 0);
10169               continue;
10170             }
10171
10172           if (TREE_CODE (type) == OFFSET_TYPE
10173               && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10174                   || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10175             {
10176               cp_error ("cannot declare pointer to `%#T' member",
10177                         TREE_TYPE (type));
10178               type = TREE_TYPE (type);
10179             }
10180
10181           /* Merge any constancy or volatility into the target type
10182              for the pointer.  */
10183
10184           /* We now know that the TYPE_QUALS don't apply to the decl,
10185              but to the target of the pointer.  */
10186           type_quals = TYPE_UNQUALIFIED;
10187
10188           if (TREE_CODE (declarator) == ADDR_EXPR)
10189             {
10190               if (TREE_CODE (type) == VOID_TYPE)
10191                 error ("invalid type: `void &'");
10192               else
10193                 type = build_reference_type (type);
10194             }
10195           else if (TREE_CODE (type) == METHOD_TYPE)
10196             type = build_ptrmemfunc_type (build_pointer_type (type));
10197           else
10198             type = build_pointer_type (type);
10199
10200           /* Process a list of type modifier keywords (such as
10201              const or volatile) that were given inside the `*' or `&'.  */
10202
10203           if (TREE_TYPE (declarator))
10204             {
10205               register tree typemodlist;
10206               int erred = 0;
10207
10208               constp = 0;
10209               volatilep = 0;
10210               restrictp = 0;
10211               for (typemodlist = TREE_TYPE (declarator); typemodlist;
10212                    typemodlist = TREE_CHAIN (typemodlist))
10213                 {
10214                   tree qualifier = TREE_VALUE (typemodlist);
10215
10216                   if (qualifier == ridpointers[(int) RID_CONST])
10217                     constp++;
10218                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
10219                     volatilep++;
10220                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
10221                     restrictp++;
10222                   else if (!erred)
10223                     {
10224                       erred = 1;
10225                       error ("invalid type modifier within pointer declarator");
10226                     }
10227                 }
10228               if (constp > 1)
10229                 pedwarn ("duplicate `const'");
10230               if (volatilep > 1)
10231                 pedwarn ("duplicate `volatile'");
10232               if (restrictp > 1)
10233                 pedwarn ("duplicate `restrict'");
10234
10235               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10236                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10237                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10238               if (TREE_CODE (declarator) == ADDR_EXPR
10239                   && (constp || volatilep))
10240                 {
10241                   if (constp)
10242                     pedwarn ("discarding `const' applied to a reference");
10243                   if (volatilep)
10244                     pedwarn ("discarding `volatile' applied to a reference");
10245                   type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
10246                 }
10247               type = cp_build_qualified_type (type, type_quals);
10248             }
10249           declarator = TREE_OPERAND (declarator, 0);
10250           ctype = NULL_TREE;
10251           break;
10252
10253         case SCOPE_REF:
10254           {
10255             /* We have converted type names to NULL_TREE if the
10256                name was bogus, or to a _TYPE node, if not.
10257
10258                The variable CTYPE holds the type we will ultimately
10259                resolve to.  The code here just needs to build
10260                up appropriate member types.  */
10261             tree sname = TREE_OPERAND (declarator, 1);
10262             tree t;
10263
10264             /* Destructors can have their visibilities changed as well.  */
10265             if (TREE_CODE (sname) == BIT_NOT_EXPR)
10266               sname = TREE_OPERAND (sname, 0);
10267
10268             if (TREE_COMPLEXITY (declarator) == 0)
10269               /* This needs to be here, in case we are called
10270                  multiple times.  */ ;
10271             else if (TREE_COMPLEXITY (declarator) == -1)
10272               /* Namespace member. */
10273               pop_decl_namespace ();
10274             else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
10275               /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10276             else if (! IS_AGGR_TYPE_CODE
10277                      (TREE_CODE (TREE_OPERAND (declarator, 0))))
10278               ;
10279             else if (TREE_COMPLEXITY (declarator) == current_class_depth)
10280               {
10281                 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10282                    that refer to ctype.  They couldn't be resolved earlier
10283                    because we hadn't pushed into the class yet.
10284                    Example: resolve 'B<T>::type' in
10285                    'B<typename B<T>::type> B<T>::f () { }'.  */
10286                 if (current_template_parms
10287                     && uses_template_parms (type)
10288                     && uses_template_parms (current_class_type))
10289                   {
10290                     tree args = current_template_args ();
10291                     type = tsubst (type, args, /*complain=*/1, NULL_TREE);
10292                   }
10293
10294                 /* This pop_nested_class corresponds to the
10295                    push_nested_class used to push into class scope for
10296                    parsing the argument list of a function decl, in
10297                    qualified_id.  */
10298                 pop_nested_class ();
10299                 TREE_COMPLEXITY (declarator) = current_class_depth;
10300               }
10301             else
10302               my_friendly_abort (16);
10303
10304             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
10305               {
10306                 /* We had a reference to a global decl, or
10307                    perhaps we were given a non-aggregate typedef,
10308                    in which case we cleared this out, and should just
10309                    keep going as though it wasn't there.  */
10310                 declarator = sname;
10311                 continue;
10312               }
10313             ctype = TREE_OPERAND (declarator, 0);
10314
10315             t = ctype;
10316             while (t != NULL_TREE && CLASS_TYPE_P (t))
10317               {
10318                 if (CLASSTYPE_TEMPLATE_INFO (t) &&
10319                     !CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
10320                   template_count += 1;
10321                 t = TYPE_MAIN_DECL (t);
10322                 if (DECL_LANG_SPECIFIC (t))
10323                   t = DECL_CLASS_CONTEXT (t);
10324                 else
10325                   t = NULL_TREE;
10326               }
10327
10328             if (sname == NULL_TREE)
10329               goto done_scoping;
10330
10331             if (TREE_CODE (sname) == IDENTIFIER_NODE)
10332               {
10333                 /* This is the `standard' use of the scoping operator:
10334                    basetype :: member .  */
10335
10336                 if (ctype == current_class_type)
10337                   {
10338                     /* class A {
10339                          void A::f ();
10340                        };
10341
10342                        Is this ill-formed?  */
10343
10344                     if (pedantic)
10345                       cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10346                                   ctype, name);
10347                   }
10348                 else if (TREE_CODE (type) == FUNCTION_TYPE)
10349                   {
10350                     if (current_class_type == NULL_TREE
10351                         || friendp)
10352                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10353                                                       TYPE_ARG_TYPES (type));
10354                     else
10355                       {
10356                         cp_error ("cannot declare member function `%T::%s' within `%T'",
10357                                   ctype, name, current_class_type);
10358                         return void_type_node;
10359                       }
10360                   }
10361                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
10362                          || TYPE_SIZE (complete_type (ctype)) != NULL_TREE)
10363                   {
10364                     /* Have to move this code elsewhere in this function.
10365                        this code is used for i.e., typedef int A::M; M *pm;
10366
10367                        It is?  How? jason 10/2/94 */
10368
10369                     if (current_class_type)
10370                       {
10371                         cp_error ("cannot declare member `%T::%s' within `%T'",
10372                                   ctype, name, current_class_type);
10373                         return void_type_node;
10374                       }
10375                     type = build_offset_type (ctype, type);
10376                   }
10377                 else if (uses_template_parms (ctype))
10378                   {
10379                     if (TREE_CODE (type) == FUNCTION_TYPE)
10380                       type
10381                         = build_cplus_method_type (ctype, TREE_TYPE (type),
10382                                                    TYPE_ARG_TYPES (type));
10383                   }
10384                 else
10385                   {
10386                     cp_error ("structure `%T' not yet defined", ctype);
10387                     return error_mark_node;
10388                   }
10389
10390                 declarator = sname;
10391               }
10392             else if (TREE_CODE (sname) == SCOPE_REF)
10393               my_friendly_abort (17);
10394             else
10395               {
10396               done_scoping:
10397                 declarator = TREE_OPERAND (declarator, 1);
10398                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
10399                   /* In this case, we will deal with it later.  */
10400                   ;
10401                 else
10402                   {
10403                     if (TREE_CODE (type) == FUNCTION_TYPE)
10404                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10405                                                       TYPE_ARG_TYPES (type));
10406                     else
10407                       type = build_offset_type (ctype, type);
10408                   }
10409               }
10410           }
10411           break;
10412
10413         case BIT_NOT_EXPR:
10414           declarator = TREE_OPERAND (declarator, 0);
10415           break;
10416
10417         case RECORD_TYPE:
10418         case UNION_TYPE:
10419         case ENUMERAL_TYPE:
10420           declarator = NULL_TREE;
10421           break;
10422
10423         case ERROR_MARK:
10424           declarator = NULL_TREE;
10425           break;
10426
10427         default:
10428           my_friendly_abort (158);
10429         }
10430     }
10431
10432   /* See the comment for the TREE_LIST case, above.  */
10433   if (inner_attrs)
10434     {
10435       if (! ignore_attrs)
10436         decl_attributes (type, inner_attrs, NULL_TREE);
10437       else if (attrlist)
10438         TREE_VALUE (attrlist) = chainon (inner_attrs, TREE_VALUE (attrlist));
10439       else
10440         attrlist = build_decl_list (NULL_TREE, inner_attrs);
10441     }
10442
10443   /* Now TYPE has the actual type.  */
10444
10445   if (explicitp == 1 || (explicitp && friendp))
10446     {
10447       /* [dcl.fct.spec] The explicit specifier shall only be used in
10448          declarations of constructors within a class definition.  */
10449       error ("only declarations of constructors can be `explicit'");
10450       explicitp = 0;
10451     }
10452
10453   if (RIDBIT_SETP (RID_MUTABLE, specbits))
10454     {
10455       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
10456         {
10457           error ("non-member `%s' cannot be declared `mutable'", name);
10458           RIDBIT_RESET (RID_MUTABLE, specbits);
10459         }
10460       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
10461         {
10462           error ("non-object member `%s' cannot be declared `mutable'", name);
10463           RIDBIT_RESET (RID_MUTABLE, specbits);
10464         }
10465       else if (TREE_CODE (type) == FUNCTION_TYPE
10466                || TREE_CODE (type) == METHOD_TYPE)
10467         {
10468           error ("function `%s' cannot be declared `mutable'", name);
10469           RIDBIT_RESET (RID_MUTABLE, specbits);
10470         }
10471       else if (staticp)
10472         {
10473           error ("static `%s' cannot be declared `mutable'", name);
10474           RIDBIT_RESET (RID_MUTABLE, specbits);
10475         }
10476       else if (type_quals & TYPE_QUAL_CONST)
10477         {
10478           error ("const `%s' cannot be declared `mutable'", name);
10479           RIDBIT_RESET (RID_MUTABLE, specbits);
10480         }
10481     }
10482
10483   if (declarator == NULL_TREE
10484       || TREE_CODE (declarator) == IDENTIFIER_NODE
10485       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
10486           && (TREE_CODE (type) == FUNCTION_TYPE
10487               || TREE_CODE (type) == METHOD_TYPE)))
10488     /* OK */;
10489   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
10490     {
10491       cp_error ("template-id `%D' used as a declarator", declarator);
10492       declarator = dname;
10493     }
10494   else
10495     /* Unexpected declarator format.  */
10496     my_friendly_abort (990210);
10497
10498   /* If this is declaring a typedef name, return a TYPE_DECL.  */
10499
10500   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
10501     {
10502       tree decl;
10503
10504       /* Note that the grammar rejects storage classes
10505          in typenames, fields or parameters.  */
10506       if (current_lang_name == lang_name_java)
10507         TYPE_FOR_JAVA (type) = 1;
10508
10509       if (decl_context == FIELD)
10510         {
10511           if (declarator == constructor_name (current_class_type))
10512             cp_pedwarn ("ANSI C++ forbids nested type `%D' with same name as enclosing class",
10513                         declarator);
10514           decl = build_lang_decl (TYPE_DECL, declarator, type);
10515         }
10516       else
10517         {
10518           /* Make sure this typedef lives as long as its type,
10519              since it might be used as a template parameter. */
10520           if (type != error_mark_node)
10521             push_obstacks (TYPE_OBSTACK (type), TYPE_OBSTACK (type));
10522           if (processing_template_decl)
10523             decl = build_lang_decl (TYPE_DECL, declarator, type);
10524           else
10525             decl = build_decl (TYPE_DECL, declarator, type);
10526           if (type != error_mark_node)
10527             pop_obstacks ();
10528         }
10529
10530       /* If the user declares "typedef struct {...} foo" then the
10531          struct will have an anonymous name.  Fill that name in now.
10532          Nothing can refer to it, so nothing needs know about the name
10533          change.  */
10534       if (type != error_mark_node
10535           && TYPE_NAME (type)
10536           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
10537           && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type))
10538           && CP_TYPE_QUALS (type) == TYPE_UNQUALIFIED)
10539         {
10540           tree oldname = TYPE_NAME (type);
10541           tree t;
10542
10543           /* Replace the anonymous name with the real name everywhere.  */
10544           lookup_tag_reverse (type, declarator);
10545           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
10546             if (TYPE_NAME (t) == oldname)
10547               TYPE_NAME (t) = decl;
10548
10549           if (TYPE_LANG_SPECIFIC (type))
10550             TYPE_WAS_ANONYMOUS (type) = 1;
10551
10552           /* If this is a typedef within a template class, the nested
10553              type is a (non-primary) template.  The name for the
10554              template needs updating as well.  */
10555           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
10556             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
10557               = TYPE_IDENTIFIER (type);
10558
10559           /* XXX Temporarily set the scope.
10560              When returning, start_decl expects it as NULL_TREE,
10561              and will then then set it using pushdecl. */
10562           my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 980404);
10563           if (current_class_type)
10564             DECL_CONTEXT (decl) = current_class_type;
10565           else
10566             DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
10567
10568           DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
10569           DECL_ASSEMBLER_NAME (decl)
10570             = get_identifier (build_overload_name (type, 1, 1));
10571           DECL_CONTEXT (decl) = NULL_TREE;
10572
10573           /* FIXME remangle member functions; member functions of a
10574              type with external linkage have external linkage.  */
10575         }
10576
10577       if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
10578         {
10579           cp_error_at ("typedef name may not be class-qualified", decl);
10580           return NULL_TREE;
10581         }
10582       else if (quals)
10583         {
10584           if (ctype == NULL_TREE)
10585             {
10586               if (TREE_CODE (type) != METHOD_TYPE)
10587                 cp_error_at ("invalid type qualifier for non-method type", decl);
10588               else
10589                 ctype = TYPE_METHOD_BASETYPE (type);
10590             }
10591           if (ctype != NULL_TREE)
10592             grok_method_quals (ctype, decl, quals);
10593         }
10594
10595       if (RIDBIT_SETP (RID_SIGNED, specbits)
10596           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
10597         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
10598
10599       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
10600                       inlinep, friendp, raises != NULL_TREE);
10601
10602       if (initialized)
10603         error ("typedef declaration includes an initializer");
10604
10605       return decl;
10606     }
10607
10608   /* Detect the case of an array type of unspecified size
10609      which came, as such, direct from a typedef name.
10610      We must copy the type, so that each identifier gets
10611      a distinct type, so that each identifier's size can be
10612      controlled separately by its own initializer.  */
10613
10614   if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
10615       && TYPE_DOMAIN (type) == NULL_TREE)
10616     {
10617       type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
10618     }
10619
10620   /* If this is a type name (such as, in a cast or sizeof),
10621      compute the type and return it now.  */
10622
10623   if (decl_context == TYPENAME)
10624     {
10625       /* Note that the grammar rejects storage classes
10626          in typenames, fields or parameters.  */
10627       if (type_quals != TYPE_UNQUALIFIED)
10628         type_quals = TYPE_UNQUALIFIED;
10629
10630       /* Special case: "friend class foo" looks like a TYPENAME context.  */
10631       if (friendp)
10632         {
10633           if (type_quals != TYPE_UNQUALIFIED)
10634             {
10635               cp_error ("type qualifiers specified for friend class declaration");
10636               type_quals = TYPE_UNQUALIFIED;
10637             }
10638           if (inlinep)
10639             {
10640               cp_error ("`inline' specified for friend class declaration");
10641               inlinep = 0;
10642             }
10643
10644           /* Only try to do this stuff if we didn't already give up.  */
10645           if (type != integer_type_node)
10646             {
10647               /* A friendly class?  */
10648               if (current_class_type)
10649                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
10650               else
10651                 error ("trying to make class `%s' a friend of global scope",
10652                        TYPE_NAME_STRING (type));
10653               type = void_type_node;
10654             }
10655         }
10656       else if (quals)
10657         {
10658           tree dummy = build_decl (TYPE_DECL, declarator, type);
10659           if (ctype == NULL_TREE)
10660             {
10661               my_friendly_assert (TREE_CODE (type) == METHOD_TYPE, 159);
10662               ctype = TYPE_METHOD_BASETYPE (type);
10663             }
10664           grok_method_quals (ctype, dummy, quals);
10665           type = TREE_TYPE (dummy);
10666         }
10667
10668       return type;
10669     }
10670   else if (declarator == NULL_TREE && decl_context != PARM
10671            && decl_context != CATCHPARM
10672            && TREE_CODE (type) != UNION_TYPE
10673            && ! bitfield)
10674     {
10675       cp_error ("abstract declarator `%T' used as declaration", type);
10676       declarator = make_anon_name ();
10677     }
10678
10679   /* `void' at top level (not within pointer)
10680      is allowed only in typedefs or type names.
10681      We don't complain about parms either, but that is because
10682      a better error message can be made later.  */
10683
10684   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
10685     {
10686       if (! declarator)
10687         error ("unnamed variable or field declared void");
10688       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10689         {
10690           if (IDENTIFIER_OPNAME_P (declarator))
10691             my_friendly_abort (356);
10692           else
10693             error ("variable or field `%s' declared void", name);
10694         }
10695       else
10696         error ("variable or field declared void");
10697       type = integer_type_node;
10698     }
10699
10700   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
10701      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
10702
10703   if (decl_context == PARM || decl_context == CATCHPARM)
10704     {
10705       if (ctype || in_namespace)
10706         error ("cannot use `::' in parameter declaration");
10707
10708       /* A parameter declared as an array of T is really a pointer to T.
10709          One declared as a function is really a pointer to a function.
10710          One declared as a member is really a pointer to member.  */
10711
10712       if (TREE_CODE (type) == ARRAY_TYPE)
10713         {
10714           /* Transfer const-ness of array into that of type pointed to.  */
10715           type = build_pointer_type (TREE_TYPE (type));
10716           type_quals = TYPE_UNQUALIFIED;
10717         }
10718       else if (TREE_CODE (type) == FUNCTION_TYPE)
10719         type = build_pointer_type (type);
10720       else if (TREE_CODE (type) == OFFSET_TYPE)
10721         type = build_pointer_type (type);
10722       else if (TREE_CODE (type) == VOID_TYPE && declarator)
10723         {
10724           error ("declaration of `%s' as void", name);
10725           return NULL_TREE;
10726         }
10727     }
10728
10729   {
10730     register tree decl;
10731
10732     if (decl_context == PARM)
10733       {
10734         decl = build_decl (PARM_DECL, declarator, type);
10735
10736         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
10737                         inlinep, friendp, raises != NULL_TREE);
10738
10739         /* Compute the type actually passed in the parmlist,
10740            for the case where there is no prototype.
10741            (For example, shorts and chars are passed as ints.)
10742            When there is a prototype, this is overridden later.  */
10743
10744         DECL_ARG_TYPE (decl) = type_promotes_to (type);
10745       }
10746     else if (decl_context == FIELD)
10747       {
10748         if (type == error_mark_node)
10749           {
10750             /* Happens when declaring arrays of sizes which
10751                are error_mark_node, for example.  */
10752             decl = NULL_TREE;
10753           }
10754         else if (in_namespace && !friendp)
10755           {
10756             /* Something like struct S { int N::j; };  */
10757             cp_error ("invalid use of `::'");
10758             decl = NULL_TREE;
10759           }
10760         else if (TREE_CODE (type) == FUNCTION_TYPE)
10761           {
10762             int publicp = 0;
10763             tree function_context;
10764
10765             /* We catch the others as conflicts with the builtin
10766                typedefs.  */
10767             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
10768               {
10769                 cp_error ("function `%D' cannot be declared friend",
10770                           declarator);
10771                 friendp = 0;
10772               }
10773
10774             if (friendp == 0)
10775               {
10776                 if (ctype == NULL_TREE)
10777                   ctype = current_class_type;
10778
10779                 if (ctype == NULL_TREE)
10780                   {
10781                     cp_error ("can't make `%D' into a method -- not in a class",
10782                               declarator);
10783                     return void_type_node;
10784                   }
10785
10786                 /* ``A union may [ ... ] not [ have ] virtual functions.''
10787                    ARM 9.5 */
10788                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
10789                   {
10790                     cp_error ("function `%D' declared virtual inside a union",
10791                               declarator);
10792                     return void_type_node;
10793                   }
10794
10795                 if (declarator == ansi_opname[(int) NEW_EXPR]
10796                     || declarator == ansi_opname[(int) VEC_NEW_EXPR]
10797                     || declarator == ansi_opname[(int) DELETE_EXPR]
10798                     || declarator == ansi_opname[(int) VEC_DELETE_EXPR])
10799                   {
10800                     if (virtualp)
10801                       {
10802                         cp_error ("`%D' cannot be declared virtual, since it is always static",
10803                                   declarator);
10804                         virtualp = 0;
10805                       }
10806                   }
10807                 else if (staticp < 2)
10808                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
10809                                                   TYPE_ARG_TYPES (type));
10810               }
10811
10812             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
10813             function_context = (ctype != NULL_TREE) ?
10814               hack_decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
10815             publicp = (! friendp || ! staticp)
10816               && function_context == NULL_TREE;
10817             decl = grokfndecl (ctype, type,
10818                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
10819                                ? declarator : dname,
10820                                declarator,
10821                                virtualp, flags, quals, raises,
10822                                friendp ? -1 : 0, friendp, publicp, inlinep,
10823                                funcdef_flag, template_count, in_namespace);
10824             if (decl == NULL_TREE)
10825               return decl;
10826 #if 0
10827             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
10828             /* The decl and setting of decl_machine_attr is also turned off.  */
10829             decl = build_decl_attribute_variant (decl, decl_machine_attr);
10830 #endif
10831
10832             /* [class.conv.ctor]
10833
10834                A constructor declared without the function-specifier
10835                explicit that can be called with a single parameter
10836                specifies a conversion from the type of its first
10837                parameter to the type of its class.  Such a constructor
10838                is called a converting constructor.  */
10839             if (explicitp == 2)
10840               DECL_NONCONVERTING_P (decl) = 1;
10841             else if (DECL_CONSTRUCTOR_P (decl))
10842               {
10843                 /* The constructor can be called with exactly one
10844                    parameter if there is at least one parameter, and
10845                    any subsequent parameters have default arguments.
10846                    We don't look at the first parameter, which is
10847                    really just the `this' parameter for the new
10848                    object.  */
10849                 tree arg_types =
10850                   TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)));
10851
10852                 /* Skip the `in_chrg' argument too, if present.  */
10853                 if (TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (decl)))
10854                   arg_types = TREE_CHAIN (arg_types);
10855
10856                 if (arg_types == void_list_node
10857                     || (arg_types
10858                         && TREE_CHAIN (arg_types)
10859                         && TREE_CHAIN (arg_types) != void_list_node
10860                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
10861                   DECL_NONCONVERTING_P (decl) = 1;
10862               }
10863           }
10864         else if (TREE_CODE (type) == METHOD_TYPE)
10865           {
10866             /* We only get here for friend declarations of
10867                members of other classes.  */
10868             /* All method decls are public, so tell grokfndecl to set
10869                TREE_PUBLIC, also.  */
10870             decl = grokfndecl (ctype, type, declarator, declarator,
10871                                virtualp, flags, quals, raises,
10872                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
10873                                template_count, in_namespace);
10874             if (decl == NULL_TREE)
10875               return NULL_TREE;
10876           }
10877         else if (!staticp && ! processing_template_decl
10878                  && TYPE_SIZE (complete_type (type)) == NULL_TREE
10879                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
10880           {
10881             if (declarator)
10882               cp_error ("field `%D' has incomplete type", declarator);
10883             else
10884               cp_error ("name `%T' has incomplete type", type);
10885
10886             /* If we're instantiating a template, tell them which
10887                instantiation made the field's type be incomplete.  */
10888             if (current_class_type
10889                 && TYPE_NAME (current_class_type)
10890                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
10891                 && declspecs && TREE_VALUE (declspecs)
10892                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
10893               cp_error ("  in instantiation of template `%T'",
10894                         current_class_type);
10895
10896             type = error_mark_node;
10897             decl = NULL_TREE;
10898           }
10899         else
10900           {
10901             if (friendp)
10902               {
10903                 error ("`%s' is neither function nor method; cannot be declared friend",
10904                        IDENTIFIER_POINTER (declarator));
10905                 friendp = 0;
10906               }
10907             decl = NULL_TREE;
10908           }
10909
10910         if (friendp)
10911           {
10912             /* Friends are treated specially.  */
10913             if (ctype == current_class_type)
10914               warning ("member functions are implicitly friends of their class");
10915             else
10916               {
10917                 tree t = NULL_TREE;
10918                 if (decl && DECL_NAME (decl))
10919                   {
10920                     if (template_class_depth (current_class_type) == 0)
10921                       {
10922                         decl
10923                           = check_explicit_specialization
10924                           (declarator, decl,
10925                            template_count, 2 * (funcdef_flag != 0) + 4);
10926                         if (decl == error_mark_node)
10927                           return error_mark_node;
10928                       }
10929
10930                     t = do_friend (ctype, declarator, decl,
10931                                    last_function_parms, attrlist, flags, quals,
10932                                    funcdef_flag);
10933                   }
10934                 if (t && funcdef_flag)
10935                   return t;
10936
10937                 return void_type_node;
10938               }
10939           }
10940
10941         /* Structure field.  It may not be a function, except for C++ */
10942
10943         if (decl == NULL_TREE)
10944           {
10945             if (initialized)
10946               {
10947                 if (!staticp)
10948                   {
10949                     /* An attempt is being made to initialize a non-static
10950                        member.  But, from [class.mem]:
10951
10952                        4 A member-declarator can contain a
10953                        constant-initializer only if it declares a static
10954                        member (_class.static_) of integral or enumeration
10955                        type, see _class.static.data_.
10956
10957                        This used to be relatively common practice, but
10958                        the rest of the compiler does not correctly
10959                        handle the initialization unless the member is
10960                        static so we make it static below.  */
10961                     cp_pedwarn ("ANSI C++ forbids initialization of member `%D'",
10962                                 declarator);
10963                     cp_pedwarn ("making `%D' static", declarator);
10964                     staticp = 1;
10965                   }
10966
10967                 if (uses_template_parms (type))
10968                   /* We'll check at instantiation time.  */
10969                   ;
10970                 else if (check_static_variable_definition (declarator,
10971                                                            type))
10972                   /* If we just return the declaration, crashes
10973                      will sometimes occur.  We therefore return
10974                      void_type_node, as if this was a friend
10975                      declaration, to cause callers to completely
10976                      ignore this declaration.  */
10977                   return void_type_node;
10978               }
10979
10980             /* 9.2p13 [class.mem] */
10981             if (declarator == constructor_name (current_class_type)
10982                 /* Divergence from the standard:  In extern "C", we
10983                    allow non-static data members here, because C does
10984                    and /usr/include/netinet/in.h uses that.  */
10985                 && (staticp || ! in_system_header))
10986               cp_pedwarn ("ANSI C++ forbids data member `%D' with same name as enclosing class",
10987                           declarator);
10988
10989             if (staticp)
10990               {
10991                 /* C++ allows static class members.  All other work
10992                    for this is done by grokfield.  */
10993                 decl = build_lang_decl (VAR_DECL, declarator, type);
10994                 TREE_STATIC (decl) = 1;
10995                 /* In class context, 'static' means public access.  */
10996                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
10997               }
10998             else
10999               {
11000                 decl = build_lang_decl (FIELD_DECL, declarator, type);
11001                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11002                   {
11003                     DECL_MUTABLE_P (decl) = 1;
11004                     RIDBIT_RESET (RID_MUTABLE, specbits);
11005                   }
11006               }
11007
11008             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11009                             inlinep, friendp, raises != NULL_TREE);
11010           }
11011       }
11012     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11013       {
11014         tree original_name;
11015         int publicp = 0;
11016
11017         if (! declarator)
11018           return NULL_TREE;
11019
11020         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11021           original_name = dname;
11022         else
11023           original_name = declarator;
11024
11025         if (RIDBIT_SETP (RID_AUTO, specbits))
11026           error ("storage class `auto' invalid for function `%s'", name);
11027         else if (RIDBIT_SETP (RID_REGISTER, specbits))
11028           error ("storage class `register' invalid for function `%s'", name);
11029
11030         /* Function declaration not at top level.
11031            Storage classes other than `extern' are not allowed
11032            and `extern' makes no difference.  */
11033         if (! toplevel_bindings_p ()
11034             && (RIDBIT_SETP (RID_STATIC, specbits)
11035                 || RIDBIT_SETP (RID_INLINE, specbits))
11036             && pedantic)
11037           {
11038             if (RIDBIT_SETP (RID_STATIC, specbits))
11039               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11040             else
11041               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11042           }
11043
11044         if (ctype == NULL_TREE)
11045           {
11046             if (virtualp)
11047               {
11048                 error ("virtual non-class function `%s'", name);
11049                 virtualp = 0;
11050               }
11051           }
11052         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11053           type = build_cplus_method_type (ctype, TREE_TYPE (type),
11054                                           TYPE_ARG_TYPES (type));
11055
11056         /* Record presence of `static'.  */
11057         publicp = (ctype != NULL_TREE
11058                    || RIDBIT_SETP (RID_EXTERN, specbits)
11059                    || !RIDBIT_SETP (RID_STATIC, specbits));
11060
11061         decl = grokfndecl (ctype, type, original_name, declarator,
11062                            virtualp, flags, quals, raises,
11063                            1, friendp,
11064                            publicp, inlinep, funcdef_flag,
11065                            template_count, in_namespace);
11066         if (decl == NULL_TREE)
11067           return NULL_TREE;
11068
11069         if (staticp == 1)
11070           {
11071             int illegal_static = 0;
11072
11073             /* Don't allow a static member function in a class, and forbid
11074                declaring main to be static.  */
11075             if (TREE_CODE (type) == METHOD_TYPE)
11076               {
11077                 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11078                 illegal_static = 1;
11079               }
11080             else if (current_function_decl)
11081               {
11082                 /* FIXME need arm citation */
11083                 error ("cannot declare static function inside another function");
11084                 illegal_static = 1;
11085               }
11086
11087             if (illegal_static)
11088               {
11089                 staticp = 0;
11090                 RIDBIT_RESET (RID_STATIC, specbits);
11091               }
11092           }
11093       }
11094     else
11095       {
11096         /* It's a variable.  */
11097
11098         /* An uninitialized decl with `extern' is a reference.  */
11099         decl = grokvardecl (type, declarator, &specbits,
11100                             initialized,
11101                             (type_quals & TYPE_QUAL_CONST) != 0,
11102                             in_namespace);
11103         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11104                         inlinep, friendp, raises != NULL_TREE);
11105
11106         if (ctype)
11107           {
11108             DECL_CONTEXT (decl) = ctype;
11109             if (staticp == 1)
11110               {
11111                 cp_pedwarn ("static member `%D' re-declared as static", decl);
11112                 staticp = 0;
11113                 RIDBIT_RESET (RID_STATIC, specbits);
11114               }
11115             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11116               {
11117                 cp_error ("static member `%D' declared `register'", decl);
11118                 RIDBIT_RESET (RID_REGISTER, specbits);
11119               }
11120             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11121               {
11122                 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11123                             decl);
11124                 RIDBIT_RESET (RID_EXTERN, specbits);
11125               }
11126           }
11127       }
11128
11129     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11130
11131     /* Record `register' declaration for warnings on &
11132        and in case doing stupid register allocation.  */
11133
11134     if (RIDBIT_SETP (RID_REGISTER, specbits))
11135       DECL_REGISTER (decl) = 1;
11136
11137     if (RIDBIT_SETP (RID_EXTERN, specbits))
11138       DECL_THIS_EXTERN (decl) = 1;
11139
11140     if (RIDBIT_SETP (RID_STATIC, specbits))
11141       DECL_THIS_STATIC (decl) = 1;
11142
11143     /* Record constancy and volatility.  There's no need to do this
11144        when processing a template; we'll do this for the instantiated
11145        declaration based on the type of DECL.  */
11146     if (!processing_template_decl)
11147       c_apply_type_quals_to_decl (type_quals, decl);
11148
11149     return decl;
11150   }
11151 }
11152 \f
11153 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11154    An empty exprlist is a parmlist.  An exprlist which
11155    contains only identifiers at the global level
11156    is a parmlist.  Otherwise, it is an exprlist.  */
11157
11158 int
11159 parmlist_is_exprlist (exprs)
11160      tree exprs;
11161 {
11162   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11163     return 0;
11164
11165   if (toplevel_bindings_p ())
11166     {
11167       /* At the global level, if these are all identifiers,
11168          then it is a parmlist.  */
11169       while (exprs)
11170         {
11171           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11172             return 1;
11173           exprs = TREE_CHAIN (exprs);
11174         }
11175       return 0;
11176     }
11177   return 1;
11178 }
11179
11180 /* Subroutine of start_function.  Ensure that each of the parameter
11181    types (as listed in PARMS) is complete, as is required for a
11182    function definition.  */
11183
11184 static void
11185 require_complete_types_for_parms (parms)
11186      tree parms;
11187 {
11188   while (parms)
11189     {
11190       tree type = TREE_TYPE (parms);
11191       if (TYPE_SIZE (complete_type (type)) == NULL_TREE)
11192         {
11193           if (DECL_NAME (parms))
11194             error ("parameter `%s' has incomplete type",
11195                    IDENTIFIER_POINTER (DECL_NAME (parms)));
11196           else
11197             error ("parameter has incomplete type");
11198           TREE_TYPE (parms) = error_mark_node;
11199         }
11200       else
11201         layout_decl (parms, 0);
11202
11203       parms = TREE_CHAIN (parms);
11204     }
11205 }
11206
11207 /* Returns *TP if *TP is a local variable (or parameter).  Returns
11208    NULL_TREE otherwise.  */
11209
11210 static tree
11211 local_variable_p (tp, walk_subtrees, data)
11212      tree *tp;
11213      int *walk_subtrees ATTRIBUTE_UNUSED;
11214      void *data ATTRIBUTE_UNUSED;
11215 {
11216   tree t = *tp;
11217
11218   if ((TREE_CODE (t) == VAR_DECL
11219        /* A VAR_DECL with a context that is a _TYPE is a static data
11220           member.  */
11221        && !TYPE_P (CP_DECL_CONTEXT (t))
11222        /* Any other non-local variable must be at namespace scope.  */
11223        && TREE_CODE (CP_DECL_CONTEXT (t)) != NAMESPACE_DECL)
11224       || (TREE_CODE (t) == PARM_DECL))
11225     return t;
11226
11227   return NULL_TREE;
11228 }
11229
11230 /* Check that ARG, which is a default-argument expression for a
11231    parameter DECL, is legal.  Returns ARG, or ERROR_MARK_NODE, if
11232    something goes wrong.  DECL may also be a _TYPE node, rather than a
11233    DECL, if there is no DECL available.  */
11234
11235 tree
11236 check_default_argument (decl, arg)
11237      tree decl;
11238      tree arg;
11239 {
11240   tree var;
11241   tree decl_type;
11242
11243   if (TREE_CODE (arg) == DEFAULT_ARG)
11244     /* We get a DEFAULT_ARG when looking at an in-class declaration
11245        with a default argument.  Ignore the argument for now; we'll
11246        deal with it after the class is complete.  */
11247     return arg;
11248
11249   if (processing_template_decl || uses_template_parms (arg))
11250     /* We don't do anything checking until instantiation-time.  Note
11251        that there may be uninstantiated arguments even for an
11252        instantiated function, since default arguments are not
11253        instantiated until they are needed.  */
11254     return arg;
11255
11256   if (TYPE_P (decl))
11257     {
11258       decl_type = decl;
11259       decl = NULL_TREE;
11260     }
11261   else
11262     decl_type = TREE_TYPE (decl);
11263
11264   if (arg == error_mark_node
11265       || decl == error_mark_node
11266       || TREE_TYPE (arg) == error_mark_node
11267       || decl_type == error_mark_node)
11268     /* Something already went wrong.  There's no need to check
11269        further.  */
11270     return error_mark_node;
11271
11272   /* [dcl.fct.default]
11273
11274      A default argument expression is implicitly converted to the
11275      parameter type.  */
11276   if (!TREE_TYPE (arg)
11277       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
11278     {
11279       if (decl)
11280         cp_error ("default argument for `%#D' has type `%T'",
11281                   decl, TREE_TYPE (arg));
11282       else
11283         cp_error ("default argument for parameter of type `%T' has type `%T'",
11284                   decl_type, TREE_TYPE (arg));
11285
11286       return error_mark_node;
11287     }
11288
11289   /* [dcl.fct.default]
11290
11291      Local variables shall not be used in default argument
11292      expressions.
11293
11294      The keyword `this' shall not be used in a default argument of a
11295      member function.  */
11296   var = walk_tree (&arg, local_variable_p, NULL);
11297   if (var)
11298     {
11299       cp_error ("default argument `%E' uses local variable `%D'",
11300                 arg, var);
11301       return error_mark_node;
11302     }
11303
11304   /* All is well.  */
11305   return arg;
11306 }
11307
11308 /* Decode the list of parameter types for a function type.
11309    Given the list of things declared inside the parens,
11310    return a list of types.
11311
11312    The list we receive can have three kinds of elements:
11313    an IDENTIFIER_NODE for names given without types,
11314    a TREE_LIST node for arguments given as typespecs or names with typespecs,
11315    or void_type_node, to mark the end of an argument list
11316    when additional arguments are not permitted (... was not used).
11317
11318    FUNCDEF_FLAG is nonzero for a function definition, 0 for
11319    a mere declaration.  A nonempty identifier-list gets an error message
11320    when FUNCDEF_FLAG is zero.
11321    If FUNCDEF_FLAG is 1, then parameter types must be complete.
11322    If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
11323
11324    If all elements of the input list contain types,
11325    we return a list of the types.
11326    If all elements contain no type (except perhaps a void_type_node
11327    at the end), we return a null list.
11328    If some have types and some do not, it is an error, and we
11329    return a null list.
11330
11331    Also set last_function_parms to either
11332    a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
11333    A list of names is converted to a chain of PARM_DECLs
11334    by store_parm_decls so that ultimately it is always a chain of decls.
11335
11336    Note that in C++, parameters can take default values.  These default
11337    values are in the TREE_PURPOSE field of the TREE_LIST.  It is
11338    an error to specify default values which are followed by parameters
11339    that have no default values, or an ELLIPSES.  For simplicities sake,
11340    only parameters which are specified with their types can take on
11341    default values.  */
11342
11343 static tree
11344 grokparms (first_parm, funcdef_flag)
11345      tree first_parm;
11346      int funcdef_flag;
11347 {
11348   tree result = NULL_TREE;
11349   tree decls = NULL_TREE;
11350
11351   if (first_parm != NULL_TREE
11352       && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
11353     {
11354       if (! funcdef_flag)
11355         pedwarn ("parameter names (without types) in function declaration");
11356       last_function_parms = first_parm;
11357       return NULL_TREE;
11358     }
11359   else if (first_parm != NULL_TREE
11360            && TREE_CODE (TREE_VALUE (first_parm)) != TREE_LIST
11361            && TREE_CODE (TREE_VALUE (first_parm)) != VOID_TYPE)
11362     my_friendly_abort (145);
11363   else
11364     {
11365       /* Types were specified.  This is a list of declarators
11366          each represented as a TREE_LIST node.  */
11367       register tree parm, chain;
11368       int any_init = 0, any_error = 0;
11369
11370       if (first_parm != NULL_TREE)
11371         {
11372           tree last_result = NULL_TREE;
11373           tree last_decl = NULL_TREE;
11374
11375           for (parm = first_parm; parm != NULL_TREE; parm = chain)
11376             {
11377               tree type = NULL_TREE, list_node = parm;
11378               register tree decl = TREE_VALUE (parm);
11379               tree init = TREE_PURPOSE (parm);
11380
11381               chain = TREE_CHAIN (parm);
11382               /* @@ weak defense against parse errors.  */
11383               if (TREE_CODE (decl) != VOID_TYPE
11384                   && TREE_CODE (decl) != TREE_LIST)
11385                 {
11386                   /* Give various messages as the need arises.  */
11387                   if (TREE_CODE (decl) == STRING_CST)
11388                     cp_error ("invalid string constant `%E'", decl);
11389                   else if (TREE_CODE (decl) == INTEGER_CST)
11390                     error ("invalid integer constant in parameter list, did you forget to give parameter name?");
11391                   continue;
11392                 }
11393
11394               if (TREE_CODE (decl) != VOID_TYPE)
11395                 {
11396                   decl = grokdeclarator (TREE_VALUE (decl),
11397                                          TREE_PURPOSE (decl),
11398                                          PARM, init != NULL_TREE,
11399                                          NULL_TREE);
11400                   if (! decl || TREE_TYPE (decl) == error_mark_node)
11401                     continue;
11402
11403                   /* Top-level qualifiers on the parameters are
11404                      ignored for function types.  */
11405                   type = TYPE_MAIN_VARIANT (TREE_TYPE (decl));
11406
11407                   if (TREE_CODE (type) == VOID_TYPE)
11408                     decl = void_type_node;
11409                   else if (TREE_CODE (type) == METHOD_TYPE)
11410                     {
11411                       if (DECL_NAME (decl))
11412                         /* Cannot use the decl here because
11413                            we don't have DECL_CONTEXT set up yet.  */
11414                         cp_error ("parameter `%D' invalidly declared method type",
11415                                   DECL_NAME (decl));
11416                       else
11417                         error ("parameter invalidly declared method type");
11418                       type = build_pointer_type (type);
11419                       TREE_TYPE (decl) = type;
11420                     }
11421                   else if (TREE_CODE (type) == OFFSET_TYPE)
11422                     {
11423                       if (DECL_NAME (decl))
11424                         cp_error ("parameter `%D' invalidly declared offset type",
11425                                   DECL_NAME (decl));
11426                       else
11427                         error ("parameter invalidly declared offset type");
11428                       type = build_pointer_type (type);
11429                       TREE_TYPE (decl) = type;
11430                     }
11431                   else if (abstract_virtuals_error (decl, type))
11432                     any_error = 1;  /* Seems like a good idea. */
11433                   else if (POINTER_TYPE_P (type))
11434                     {
11435                       tree t = type;
11436                       while (POINTER_TYPE_P (t)
11437                              || (TREE_CODE (t) == ARRAY_TYPE
11438                                  && TYPE_DOMAIN (t) != NULL_TREE))
11439                         t = TREE_TYPE (t);
11440                       if (TREE_CODE (t) == ARRAY_TYPE)
11441                         cp_error ("parameter type `%T' includes %s to array of unknown bound",
11442                                   type,
11443                                   TYPE_PTR_P (type) ? "pointer" : "reference");
11444                     }
11445                 }
11446
11447               if (TREE_CODE (decl) == VOID_TYPE)
11448                 {
11449                   if (result == NULL_TREE)
11450                     {
11451                       result = void_list_node;
11452                       last_result = result;
11453                     }
11454                   else
11455                     {
11456                       TREE_CHAIN (last_result) = void_list_node;
11457                       last_result = void_list_node;
11458                     }
11459                   if (chain
11460                       && (chain != void_list_node || TREE_CHAIN (chain)))
11461                     error ("`void' in parameter list must be entire list");
11462                   break;
11463                 }
11464
11465               /* Since there is a prototype, args are passed in their own types.  */
11466               DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
11467               if (PROMOTE_PROTOTYPES
11468                   && (TREE_CODE (type) == INTEGER_TYPE
11469                       || TREE_CODE (type) == ENUMERAL_TYPE)
11470                   && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
11471                 DECL_ARG_TYPE (decl) = integer_type_node;
11472               if (!any_error && init)
11473                 {
11474                   any_init++;
11475                   init = check_default_argument (decl, init);
11476                 }
11477               else
11478                 init = NULL_TREE;
11479
11480               if (decls == NULL_TREE)
11481                 {
11482                   decls = decl;
11483                   last_decl = decls;
11484                 }
11485               else
11486                 {
11487                   TREE_CHAIN (last_decl) = decl;
11488                   last_decl = decl;
11489                 }
11490               list_node = tree_cons (init, type, NULL_TREE);
11491               if (result == NULL_TREE)
11492                 {
11493                   result = list_node;
11494                   last_result = result;
11495                 }
11496               else
11497                 {
11498                   TREE_CHAIN (last_result) = list_node;
11499                   last_result = list_node;
11500                 }
11501             }
11502           if (last_result)
11503             TREE_CHAIN (last_result) = NULL_TREE;
11504           /* If there are no parameters, and the function does not end
11505              with `...', then last_decl will be NULL_TREE.  */
11506           if (last_decl != NULL_TREE)
11507             TREE_CHAIN (last_decl) = NULL_TREE;
11508         }
11509     }
11510
11511   last_function_parms = decls;
11512
11513   return result;
11514 }
11515
11516 /* Called from the parser to update an element of TYPE_ARG_TYPES for some
11517    FUNCTION_TYPE with the newly parsed version of its default argument, which
11518    was previously digested as text.  See snarf_defarg et al in lex.c.  */
11519
11520 void
11521 replace_defarg (arg, init)
11522      tree arg, init;
11523 {
11524   if (! processing_template_decl
11525       && ! can_convert_arg (TREE_VALUE (arg), TREE_TYPE (init), init))
11526     cp_pedwarn ("invalid type `%T' for default argument to `%T'",
11527                 TREE_TYPE (init), TREE_VALUE (arg));
11528   TREE_PURPOSE (arg) = init;
11529 }
11530 \f
11531 int
11532 copy_args_p (d)
11533      tree d;
11534 {
11535   tree t = FUNCTION_ARG_CHAIN (d);
11536   if (DECL_CONSTRUCTOR_P (d)
11537       && TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (d)))
11538     t = TREE_CHAIN (t);
11539   if (t && TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
11540       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t)))
11541           == DECL_CLASS_CONTEXT (d))
11542       && (TREE_CHAIN (t) == NULL_TREE
11543           || TREE_CHAIN (t) == void_list_node
11544           || TREE_PURPOSE (TREE_CHAIN (t))))
11545     return 1;
11546   return 0;
11547 }
11548
11549 /* These memoizing functions keep track of special properties which
11550    a class may have.  `grok_ctor_properties' notices whether a class
11551    has a constructor of the form X(X&), and also complains
11552    if the class has a constructor of the form X(X).
11553    `grok_op_properties' takes notice of the various forms of
11554    operator= which are defined, as well as what sorts of type conversion
11555    may apply.  Both functions take a FUNCTION_DECL as an argument.  */
11556
11557 int
11558 grok_ctor_properties (ctype, decl)
11559      tree ctype, decl;
11560 {
11561   tree parmtypes = FUNCTION_ARG_CHAIN (decl);
11562   tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
11563
11564   /* When a type has virtual baseclasses, a magical first int argument is
11565      added to any ctor so we can tell if the class has been initialized
11566      yet.  This could screw things up in this function, so we deliberately
11567      ignore the leading int if we're in that situation.  */
11568   if (TYPE_USES_VIRTUAL_BASECLASSES (ctype))
11569     {
11570       my_friendly_assert (parmtypes
11571                           && TREE_VALUE (parmtypes) == integer_type_node,
11572                           980529);
11573       parmtypes = TREE_CHAIN (parmtypes);
11574       parmtype = TREE_VALUE (parmtypes);
11575     }
11576
11577   /* [class.copy]
11578
11579      A non-template constructor for class X is a copy constructor if
11580      its first parameter is of type X&, const X&, volatile X& or const
11581      volatile X&, and either there are no other parameters or else all
11582      other parameters have default arguments.  */
11583   if (TREE_CODE (parmtype) == REFERENCE_TYPE
11584       && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype
11585       && (TREE_CHAIN (parmtypes) == NULL_TREE
11586           || TREE_CHAIN (parmtypes) == void_list_node
11587           || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
11588       && !(DECL_TEMPLATE_INSTANTIATION (decl)
11589            && is_member_template (DECL_TI_TEMPLATE (decl))))
11590     {
11591       TYPE_HAS_INIT_REF (ctype) = 1;
11592       if (CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
11593         TYPE_HAS_CONST_INIT_REF (ctype) = 1;
11594     }
11595   /* [class.copy]
11596
11597      A declaration of a constructor for a class X is ill-formed if its
11598      first parameter is of type (optionally cv-qualified) X and either
11599      there are no other parameters or else all other parameters have
11600      default arguments.
11601
11602      We *don't* complain about member template instantiations that
11603      have this form, though; they can occur as we try to decide what
11604      constructor to use during overload resolution.  Since overload
11605      resolution will never prefer such a constructor to the
11606      non-template copy constructor (which is either explicitly or
11607      implicitly defined), there's no need to worry about their
11608      existence.  Theoretically, they should never even be
11609      instantiated, but that's hard to forestall.  */
11610   else if (TYPE_MAIN_VARIANT (parmtype) == ctype
11611            && (TREE_CHAIN (parmtypes) == NULL_TREE
11612                || TREE_CHAIN (parmtypes) == void_list_node
11613                || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
11614            && !(DECL_TEMPLATE_INSTANTIATION (decl)
11615                 && is_member_template (DECL_TI_TEMPLATE (decl))))
11616     {
11617       cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
11618                 ctype, ctype);
11619       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
11620       return 0;
11621     }
11622   else if (TREE_CODE (parmtype) == VOID_TYPE
11623            || TREE_PURPOSE (parmtypes) != NULL_TREE)
11624     TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
11625
11626   return 1;
11627 }
11628
11629 /* An operator with this name can be either unary or binary.  */
11630
11631 static int
11632 ambi_op_p (name)
11633      tree name;
11634 {
11635   return (name == ansi_opname [(int) INDIRECT_REF]
11636           || name == ansi_opname [(int) ADDR_EXPR]
11637           || name == ansi_opname [(int) NEGATE_EXPR]
11638           || name == ansi_opname[(int) POSTINCREMENT_EXPR]
11639           || name == ansi_opname[(int) POSTDECREMENT_EXPR]
11640           || name == ansi_opname [(int) CONVERT_EXPR]);
11641 }
11642
11643 /* An operator with this name can only be unary.  */
11644
11645 static int
11646 unary_op_p (name)
11647      tree name;
11648 {
11649   return (name == ansi_opname [(int) TRUTH_NOT_EXPR]
11650           || name == ansi_opname [(int) BIT_NOT_EXPR]
11651           || name == ansi_opname [(int) COMPONENT_REF]
11652           || IDENTIFIER_TYPENAME_P (name));
11653 }
11654
11655 /* Do a little sanity-checking on how they declared their operator.  */
11656
11657 void
11658 grok_op_properties (decl, virtualp, friendp)
11659      tree decl;
11660      int virtualp, friendp;
11661 {
11662   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
11663   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
11664   tree name = DECL_NAME (decl);
11665
11666   if (current_class_type == NULL_TREE)
11667     friendp = 1;
11668
11669   if (! friendp)
11670     {
11671       /* [class.copy]
11672
11673          A user-declared copy assignment operator X::operator= is a
11674          non-static non-template member function of class X with
11675          exactly one parameter of type X, X&, const X&, volatile X& or
11676          const volatile X&.  */
11677       if (name == ansi_opname[(int) MODIFY_EXPR]
11678           && !(DECL_TEMPLATE_INSTANTIATION (decl)
11679                && is_member_template (DECL_TI_TEMPLATE (decl))))
11680         ;
11681       else if (name == ansi_opname[(int) CALL_EXPR])
11682         TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
11683       else if (name == ansi_opname[(int) ARRAY_REF])
11684         TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
11685       else if (name == ansi_opname[(int) COMPONENT_REF]
11686                || name == ansi_opname[(int) MEMBER_REF])
11687         TYPE_OVERLOADS_ARROW (current_class_type) = 1;
11688       else if (name == ansi_opname[(int) NEW_EXPR])
11689         TYPE_GETS_NEW (current_class_type) |= 1;
11690       else if (name == ansi_opname[(int) DELETE_EXPR])
11691         TYPE_GETS_DELETE (current_class_type) |= 1;
11692       else if (name == ansi_opname[(int) VEC_NEW_EXPR])
11693         TYPE_GETS_NEW (current_class_type) |= 2;
11694       else if (name == ansi_opname[(int) VEC_DELETE_EXPR])
11695         TYPE_GETS_DELETE (current_class_type) |= 2;
11696     }
11697
11698   if (name == ansi_opname[(int) NEW_EXPR]
11699       || name == ansi_opname[(int) VEC_NEW_EXPR])
11700     {
11701       /* When the compiler encounters the definition of A::operator new, it
11702          doesn't look at the class declaration to find out if it's static.  */
11703       if (methodp)
11704         revert_static_member_fn (&decl, NULL, NULL);
11705
11706       /* Take care of function decl if we had syntax errors.  */
11707       if (argtypes == NULL_TREE)
11708         TREE_TYPE (decl)
11709           = build_function_type (ptr_type_node,
11710                                  hash_tree_chain (integer_type_node,
11711                                                   void_list_node));
11712       else
11713         TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
11714     }
11715   else if (name == ansi_opname[(int) DELETE_EXPR]
11716            || name == ansi_opname[(int) VEC_DELETE_EXPR])
11717     {
11718       if (methodp)
11719         revert_static_member_fn (&decl, NULL, NULL);
11720
11721       if (argtypes == NULL_TREE)
11722         TREE_TYPE (decl)
11723           = build_function_type (void_type_node,
11724                                  hash_tree_chain (ptr_type_node,
11725                                                   void_list_node));
11726       else
11727         {
11728           TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
11729
11730           if (! friendp && name == ansi_opname[(int) VEC_DELETE_EXPR]
11731               && (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)))
11732                   != void_list_node))
11733             TYPE_VEC_DELETE_TAKES_SIZE (current_class_type) = 1;
11734         }
11735     }
11736   else
11737     {
11738       /* An operator function must either be a non-static member function
11739          or have at least one parameter of a class, a reference to a class,
11740          an enumeration, or a reference to an enumeration.  13.4.0.6 */
11741       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
11742         {
11743           if (IDENTIFIER_TYPENAME_P (name)
11744               || name == ansi_opname[(int) CALL_EXPR]
11745               || name == ansi_opname[(int) MODIFY_EXPR]
11746               || name == ansi_opname[(int) COMPONENT_REF]
11747               || name == ansi_opname[(int) ARRAY_REF])
11748             cp_error ("`%D' must be a nonstatic member function", decl);
11749           else
11750             {
11751               tree p = argtypes;
11752
11753               if (DECL_STATIC_FUNCTION_P (decl))
11754                 cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
11755
11756               if (p)
11757                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
11758                   {
11759                     tree arg = TREE_VALUE (p);
11760                     if (TREE_CODE (arg) == REFERENCE_TYPE)
11761                       arg = TREE_TYPE (arg);
11762
11763                     /* This lets bad template code slip through.  */
11764                     if (IS_AGGR_TYPE (arg)
11765                         || TREE_CODE (arg) == ENUMERAL_TYPE
11766                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
11767                         || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
11768                       goto foundaggr;
11769                   }
11770               cp_error
11771                 ("`%D' must have an argument of class or enumerated type",
11772                  decl);
11773             foundaggr:
11774               ;
11775             }
11776         }
11777
11778       if (name == ansi_opname[(int) CALL_EXPR])
11779         return;                 /* No restrictions on args. */
11780
11781       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
11782         {
11783           tree t = TREE_TYPE (name);
11784           if (TREE_CODE (t) == VOID_TYPE)
11785             pedwarn ("void is not a valid type conversion operator");
11786           else if (! friendp)
11787             {
11788               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
11789               const char *what = 0;
11790               if (ref)
11791                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
11792
11793               if (t == current_class_type)
11794                 what = "the same type";
11795               /* Don't force t to be complete here.  */
11796               else if (IS_AGGR_TYPE (t)
11797                        && TYPE_SIZE (t)
11798                        && DERIVED_FROM_P (t, current_class_type))
11799                 what = "a base class";
11800
11801               if (what)
11802                 warning ("conversion to %s%s will never use a type conversion operator",
11803                          ref ? "a reference to " : "", what);
11804             }
11805         }
11806
11807       if (name == ansi_opname[(int) MODIFY_EXPR])
11808         {
11809           tree parmtype;
11810
11811           if (list_length (argtypes) != 3 && methodp)
11812             {
11813               cp_error ("`%D' must take exactly one argument", decl);
11814               return;
11815             }
11816           parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
11817
11818           if (copy_assignment_arg_p (parmtype, virtualp)
11819               && ! friendp)
11820             {
11821               TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
11822               if (TREE_CODE (parmtype) != REFERENCE_TYPE
11823                   || CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
11824                 TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
11825             }
11826         }
11827       else if (name == ansi_opname[(int) COND_EXPR])
11828         {
11829           /* 13.4.0.3 */
11830           cp_error ("ANSI C++ prohibits overloading operator ?:");
11831         }
11832       else if (ambi_op_p (name))
11833         {
11834           if (list_length (argtypes) == 2)
11835             /* prefix */;
11836           else if (list_length (argtypes) == 3)
11837             {
11838               if ((name == ansi_opname[(int) POSTINCREMENT_EXPR]
11839                    || name == ansi_opname[(int) POSTDECREMENT_EXPR])
11840                   && ! processing_template_decl
11841                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
11842                 {
11843                   if (methodp)
11844                     cp_error ("postfix `%D' must take `int' as its argument",
11845                               decl);
11846                   else
11847                     cp_error
11848                       ("postfix `%D' must take `int' as its second argument",
11849                        decl);
11850                 }
11851             }
11852           else
11853             {
11854               if (methodp)
11855                 cp_error ("`%D' must take either zero or one argument", decl);
11856               else
11857                 cp_error ("`%D' must take either one or two arguments", decl);
11858             }
11859
11860           /* More Effective C++ rule 6.  */
11861           if (warn_ecpp
11862               && (name == ansi_opname[(int) POSTINCREMENT_EXPR]
11863                   || name == ansi_opname[(int) POSTDECREMENT_EXPR]))
11864             {
11865               tree arg = TREE_VALUE (argtypes);
11866               tree ret = TREE_TYPE (TREE_TYPE (decl));
11867               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
11868                 arg = TREE_TYPE (arg);
11869               arg = TYPE_MAIN_VARIANT (arg);
11870               if (list_length (argtypes) == 2)
11871                 {
11872                   if (TREE_CODE (ret) != REFERENCE_TYPE
11873                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
11874                                        arg))
11875                     cp_warning ("prefix `%D' should return `%T'", decl,
11876                                 build_reference_type (arg));
11877                 }
11878               else
11879                 {
11880                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
11881                     cp_warning ("postfix `%D' should return `%T'", decl, arg);
11882                 }
11883             }
11884         }
11885       else if (unary_op_p (name))
11886         {
11887           if (list_length (argtypes) != 2)
11888             {
11889               if (methodp)
11890                 cp_error ("`%D' must take `void'", decl);
11891               else
11892                 cp_error ("`%D' must take exactly one argument", decl);
11893             }
11894         }
11895       else /* if (binary_op_p (name)) */
11896         {
11897           if (list_length (argtypes) != 3)
11898             {
11899               if (methodp)
11900                 cp_error ("`%D' must take exactly one argument", decl);
11901               else
11902                 cp_error ("`%D' must take exactly two arguments", decl);
11903             }
11904
11905           /* More Effective C++ rule 7.  */
11906           if (warn_ecpp
11907               && (name == ansi_opname [TRUTH_ANDIF_EXPR]
11908                   || name == ansi_opname [TRUTH_ORIF_EXPR]
11909                   || name == ansi_opname [COMPOUND_EXPR]))
11910             cp_warning ("user-defined `%D' always evaluates both arguments",
11911                         decl);
11912         }
11913
11914       /* Effective C++ rule 23.  */
11915       if (warn_ecpp
11916           && list_length (argtypes) == 3
11917           && (name == ansi_opname [PLUS_EXPR]
11918               || name == ansi_opname [MINUS_EXPR]
11919               || name == ansi_opname [TRUNC_DIV_EXPR]
11920               || name == ansi_opname [MULT_EXPR])
11921           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
11922         cp_warning ("`%D' should return by value", decl);
11923
11924       /* 13.4.0.8 */
11925       if (argtypes)
11926         for (; argtypes != void_list_node ; argtypes = TREE_CHAIN (argtypes))
11927           if (TREE_PURPOSE (argtypes))
11928             {
11929               TREE_PURPOSE (argtypes) = NULL_TREE;
11930               if (name == ansi_opname[(int) POSTINCREMENT_EXPR]
11931                   || name == ansi_opname[(int) POSTDECREMENT_EXPR])
11932                 {
11933                   if (pedantic)
11934                     cp_pedwarn ("`%D' cannot have default arguments", decl);
11935                 }
11936               else
11937                 cp_error ("`%D' cannot have default arguments", decl);
11938             }
11939     }
11940 }
11941 \f
11942 static const char *
11943 tag_name (code)
11944      enum tag_types code;
11945 {
11946   switch (code)
11947     {
11948     case record_type:
11949       return "struct";
11950     case class_type:
11951       return "class";
11952     case union_type:
11953       return "union ";
11954     case enum_type:
11955       return "enum";
11956     default:
11957       my_friendly_abort (981122);
11958     }
11959 }
11960
11961 /* Get the struct, enum or union (CODE says which) with tag NAME.
11962    Define the tag as a forward-reference if it is not defined.
11963
11964    C++: If a class derivation is given, process it here, and report
11965    an error if multiple derivation declarations are not identical.
11966
11967    If this is a definition, come in through xref_tag and only look in
11968    the current frame for the name (since C++ allows new names in any
11969    scope.)  */
11970
11971 tree
11972 xref_tag (code_type_node, name, globalize)
11973      tree code_type_node;
11974      tree name;
11975      int globalize;
11976 {
11977   enum tag_types tag_code;
11978   enum tree_code code;
11979   int temp = 0;
11980   register tree ref, t;
11981   struct binding_level *b = current_binding_level;
11982   int got_type = 0;
11983   tree attributes = NULL_TREE;
11984   tree context = NULL_TREE;
11985
11986   /* If we are called from the parser, code_type_node will sometimes be a
11987      TREE_LIST.  This indicates that the user wrote
11988      "class __attribute__ ((foo)) bar".  Extract the attributes so we can
11989      use them later.  */
11990   if (TREE_CODE (code_type_node) == TREE_LIST)
11991     {
11992       attributes = TREE_PURPOSE (code_type_node);
11993       code_type_node = TREE_VALUE (code_type_node);
11994     }
11995
11996   tag_code = (enum tag_types) TREE_INT_CST_LOW (code_type_node);
11997   switch (tag_code)
11998     {
11999     case record_type:
12000     case class_type:
12001       code = RECORD_TYPE;
12002       break;
12003     case union_type:
12004       code = UNION_TYPE;
12005       break;
12006     case enum_type:
12007       code = ENUMERAL_TYPE;
12008       break;
12009     default:
12010       my_friendly_abort (18);
12011     }
12012
12013   /* If a cross reference is requested, look up the type
12014      already defined for this tag and return it.  */
12015   if (TREE_CODE_CLASS (TREE_CODE (name)) == 't')
12016     {
12017       t = name;
12018       name = TYPE_IDENTIFIER (t);
12019       got_type = 1;
12020     }
12021   else
12022     t = IDENTIFIER_TYPE_VALUE (name);
12023
12024   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12025       && TREE_CODE (t) != TEMPLATE_TEMPLATE_PARM)
12026     t = NULL_TREE;
12027
12028   if (! globalize)
12029     {
12030       /* If we know we are defining this tag, only look it up in
12031          this scope and don't try to find it as a type.  */
12032       ref = lookup_tag (code, name, b, 1);
12033     }
12034   else
12035     {
12036       if (t)
12037         {
12038           /* [dcl.type.elab] If the identifier resolves to a
12039              typedef-name or a template type-parameter, the
12040              elaborated-type-specifier is ill-formed.  */
12041           if (t != TYPE_MAIN_VARIANT (t)
12042               || (CLASS_TYPE_P (t) && TYPE_WAS_ANONYMOUS (t)))
12043             cp_pedwarn ("using typedef-name `%D' after `%s'",
12044                         TYPE_NAME (t), tag_name (tag_code));
12045           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12046             cp_error ("using template type parameter `%T' after `%s'",
12047                       t, tag_name (tag_code));
12048
12049           ref = t;
12050         }
12051       else
12052         ref = lookup_tag (code, name, b, 0);
12053
12054       if (! ref)
12055         {
12056           /* Try finding it as a type declaration.  If that wins,
12057              use it.  */
12058           ref = lookup_name (name, 1);
12059
12060           if (ref != NULL_TREE
12061               && processing_template_decl
12062               && DECL_CLASS_TEMPLATE_P (ref)
12063               && template_class_depth (current_class_type) == 0)
12064             /* Since GLOBALIZE is true, we're declaring a global
12065                template, so we want this type.  */
12066             ref = DECL_RESULT (ref);
12067
12068           if (ref && TREE_CODE (ref) == TYPE_DECL
12069               && TREE_CODE (TREE_TYPE (ref)) == code)
12070             ref = TREE_TYPE (ref);
12071           else
12072             ref = NULL_TREE;
12073         }
12074
12075       if (ref && current_class_type
12076           && template_class_depth (current_class_type)
12077           && PROCESSING_REAL_TEMPLATE_DECL_P ())
12078         {
12079           /* Since GLOBALIZE is non-zero, we are not looking at a
12080              definition of this tag.  Since, in addition, we are currently
12081              processing a (member) template declaration of a template
12082              class, we must be very careful; consider:
12083
12084                template <class X>
12085                struct S1
12086
12087                template <class U>
12088                struct S2
12089                { template <class V>
12090                friend struct S1; };
12091
12092              Here, the S2::S1 declaration should not be confused with the
12093              outer declaration.  In particular, the inner version should
12094              have a template parameter of level 2, not level 1.  This
12095              would be particularly important if the member declaration
12096              were instead:
12097
12098                template <class V = U> friend struct S1;
12099
12100              say, when we should tsubst into `U' when instantiating
12101              S2.  On the other hand, when presented with:
12102
12103                  template <class T>
12104                  struct S1 {
12105                    template <class U>
12106                    struct S2 {};
12107                    template <class U>
12108                    friend struct S2;
12109                  };
12110
12111               we must find the inner binding eventually.  We
12112               accomplish this by making sure that the new type we
12113               create to represent this declaration has the right
12114               TYPE_CONTEXT.  */
12115           context = TYPE_CONTEXT (ref);
12116           ref = NULL_TREE;
12117         }
12118     }
12119
12120   push_obstacks_nochange ();
12121
12122   if (! ref)
12123     {
12124       /* If no such tag is yet defined, create a forward-reference node
12125          and record it as the "definition".
12126          When a real declaration of this type is found,
12127          the forward-reference will be altered into a real type.  */
12128
12129       /* In C++, since these migrate into the global scope, we must
12130          build them on the permanent obstack.  */
12131
12132       temp = allocation_temporary_p ();
12133       if (temp)
12134         end_temporary_allocation ();
12135
12136       if (code == ENUMERAL_TYPE)
12137         {
12138           cp_error ("use of enum `%#D' without previous declaration", name);
12139
12140           ref = make_node (ENUMERAL_TYPE);
12141
12142           /* Give the type a default layout like unsigned int
12143              to avoid crashing if it does not get defined.  */
12144           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12145           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12146           TREE_UNSIGNED (ref) = 1;
12147           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12148           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12149           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12150
12151           /* Enable us to recognize when a type is created in class context.
12152              To do nested classes correctly, this should probably be cleared
12153              out when we leave this classes scope.  Currently this in only
12154              done in `start_enum'.  */
12155
12156           pushtag (name, ref, globalize);
12157         }
12158       else
12159         {
12160           struct binding_level *old_b = class_binding_level;
12161
12162           ref = make_lang_type (code);
12163           TYPE_CONTEXT (ref) = context;
12164
12165 #ifdef NONNESTED_CLASSES
12166           /* Class types don't nest the way enums do.  */
12167           class_binding_level = (struct binding_level *)0;
12168 #endif
12169           pushtag (name, ref, globalize);
12170           class_binding_level = old_b;
12171         }
12172     }
12173   else
12174     {
12175       /* If it no longer looks like a nested type, make sure it's
12176          in global scope.
12177          If it is not an IDENTIFIER, this is not a declaration */
12178       if (b->namespace_p && !class_binding_level
12179           && TREE_CODE (name) == IDENTIFIER_NODE
12180           && IDENTIFIER_NAMESPACE_VALUE (name) == NULL_TREE)
12181         SET_IDENTIFIER_NAMESPACE_VALUE (name, TYPE_NAME (ref));
12182
12183       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12184         redeclare_class_template (ref, current_template_parms);
12185     }
12186
12187   /* Until the type is defined, tentatively accept whatever
12188      structure tag the user hands us.  */
12189   if (TYPE_SIZE (ref) == NULL_TREE
12190       && ref != current_class_type
12191       /* Have to check this, in case we have contradictory tag info.  */
12192       && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
12193     {
12194       if (tag_code == class_type)
12195         CLASSTYPE_DECLARED_CLASS (ref) = 1;
12196       else if (tag_code == record_type)
12197         CLASSTYPE_DECLARED_CLASS (ref) = 0;
12198     }
12199
12200   pop_obstacks ();
12201
12202   TREE_TYPE (ref) = attributes;
12203
12204   return ref;
12205 }
12206
12207 tree
12208 xref_tag_from_type (old, id, globalize)
12209      tree old, id;
12210      int globalize;
12211 {
12212   tree code_type_node;
12213
12214   if (TREE_CODE (old) == RECORD_TYPE)
12215     code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
12216                       ? class_type_node : record_type_node);
12217   else
12218     code_type_node = union_type_node;
12219
12220   if (id == NULL_TREE)
12221     id = TYPE_IDENTIFIER (old);
12222
12223   return xref_tag (code_type_node, id, globalize);
12224 }
12225
12226 /* REF is a type (named NAME), for which we have just seen some
12227    baseclasses.  BINFO is a list of those baseclasses; the
12228    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12229    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
12230    struct, or union.  */
12231
12232 void
12233 xref_basetypes (code_type_node, name, ref, binfo)
12234      tree code_type_node;
12235      tree name, ref;
12236      tree binfo;
12237 {
12238   /* In the declaration `A : X, Y, ... Z' we mark all the types
12239      (A, X, Y, ..., Z) so we can check for duplicates.  */
12240   tree binfos;
12241   tree base;
12242
12243   int i, len;
12244   enum tag_types tag_code = (enum tag_types) TREE_INT_CST_LOW (code_type_node);
12245
12246   if (tag_code == union_type)
12247     {
12248       cp_error ("derived union `%T' invalid", ref);
12249       return;
12250     }
12251
12252   len = list_length (binfo);
12253   push_obstacks (TYPE_OBSTACK (ref), TYPE_OBSTACK (ref));
12254
12255   /* First, make sure that any templates in base-classes are
12256      instantiated.  This ensures that if we call ourselves recursively
12257      we do not get confused about which classes are marked and which
12258      are not.  */
12259   for (base = binfo; base; base = TREE_CHAIN (base))
12260     complete_type (TREE_VALUE (base));
12261
12262   SET_CLASSTYPE_MARKED (ref);
12263   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
12264
12265   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
12266     {
12267       /* The base of a derived struct is public by default.  */
12268       int via_public
12269         = (TREE_PURPOSE (binfo) == access_public_node
12270            || TREE_PURPOSE (binfo) == access_public_virtual_node
12271            || (tag_code != class_type
12272                && (TREE_PURPOSE (binfo) == access_default_node
12273                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
12274       int via_protected
12275         = (TREE_PURPOSE (binfo) == access_protected_node
12276            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
12277       int via_virtual
12278         = (TREE_PURPOSE (binfo) == access_private_virtual_node
12279            || TREE_PURPOSE (binfo) == access_protected_virtual_node
12280            || TREE_PURPOSE (binfo) == access_public_virtual_node
12281            || TREE_PURPOSE (binfo) == access_default_virtual_node);
12282       tree basetype = TREE_VALUE (binfo);
12283       tree base_binfo;
12284
12285       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
12286         basetype = TREE_TYPE (basetype);
12287       if (!basetype
12288           || (TREE_CODE (basetype) != RECORD_TYPE
12289               && TREE_CODE (basetype) != TYPENAME_TYPE
12290               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
12291               && TREE_CODE (basetype) != TEMPLATE_TEMPLATE_PARM))
12292         {
12293           cp_error ("base type `%T' fails to be a struct or class type",
12294                     TREE_VALUE (binfo));
12295           continue;
12296         }
12297
12298       GNU_xref_hier (name, basetype, via_public, via_virtual, 0);
12299
12300       /* This code replaces similar code in layout_basetypes.
12301          We put the complete_type first for implicit `typename'.  */
12302       if (TYPE_SIZE (basetype) == NULL_TREE
12303           && ! (current_template_parms && uses_template_parms (basetype)))
12304         {
12305           cp_error ("base class `%T' has incomplete type", basetype);
12306           continue;
12307         }
12308       else
12309         {
12310           if (CLASSTYPE_MARKED (basetype))
12311             {
12312               if (basetype == ref)
12313                 cp_error ("recursive type `%T' undefined", basetype);
12314               else
12315                 cp_error ("duplicate base type `%T' invalid", basetype);
12316               continue;
12317             }
12318
12319           if (TYPE_FOR_JAVA (basetype)
12320               && (current_lang_stack
12321                   == &VARRAY_TREE (current_lang_base, 0)))
12322             TYPE_FOR_JAVA (ref) = 1;
12323
12324           /* Note that the BINFO records which describe individual
12325              inheritances are *not* shared in the lattice!  They
12326              cannot be shared because a given baseclass may be
12327              inherited with different `accessibility' by different
12328              derived classes.  (Each BINFO record describing an
12329              individual inheritance contains flags which say what
12330              the `accessibility' of that particular inheritance is.)  */
12331
12332           base_binfo
12333             = make_binfo (integer_zero_node, basetype,
12334                           CLASS_TYPE_P (basetype)
12335                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
12336                           CLASS_TYPE_P (basetype)
12337                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
12338
12339           TREE_VEC_ELT (binfos, i) = base_binfo;
12340           TREE_VIA_PUBLIC (base_binfo) = via_public;
12341           TREE_VIA_PROTECTED (base_binfo) = via_protected;
12342           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
12343           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
12344
12345           /* We need to unshare the binfos now so that lookups during class
12346              definition work.  */
12347           unshare_base_binfos (base_binfo);
12348
12349           SET_CLASSTYPE_MARKED (basetype);
12350
12351           /* We are free to modify these bits because they are meaningless
12352              at top level, and BASETYPE is a top-level type.  */
12353           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
12354             {
12355               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
12356               TYPE_USES_COMPLEX_INHERITANCE (ref) = 1;
12357             }
12358
12359           if (CLASS_TYPE_P (basetype))
12360             {
12361               TYPE_GETS_NEW (ref) |= TYPE_GETS_NEW (basetype);
12362               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
12363             }
12364
12365           i += 1;
12366         }
12367     }
12368   if (i)
12369     TREE_VEC_LENGTH (binfos) = i;
12370   else
12371     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
12372
12373   if (i > 1)
12374     TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
12375   else if (i == 1)
12376     {
12377       tree basetype = BINFO_TYPE (TREE_VEC_ELT (binfos, 0));
12378
12379       if (CLASS_TYPE_P (basetype))
12380         TYPE_USES_MULTIPLE_INHERITANCE (ref)
12381           = TYPE_USES_MULTIPLE_INHERITANCE (basetype);
12382     }
12383
12384   if (TYPE_USES_MULTIPLE_INHERITANCE (ref))
12385     TYPE_USES_COMPLEX_INHERITANCE (ref) = 1;
12386
12387   /* Unmark all the types.  */
12388   while (--i >= 0)
12389     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
12390   CLEAR_CLASSTYPE_MARKED (ref);
12391
12392   /* Now that we know all the base-classes, set up the list of virtual
12393      bases.  */
12394   CLASSTYPE_VBASECLASSES (ref) = get_vbase_types (ref);
12395
12396   pop_obstacks ();
12397 }
12398
12399 \f
12400 /* Begin compiling the definition of an enumeration type.
12401    NAME is its name (or null if anonymous).
12402    Returns the type object, as yet incomplete.
12403    Also records info about it so that build_enumerator
12404    may be used to declare the individual values as they are read.  */
12405
12406 tree
12407 start_enum (name)
12408      tree name;
12409 {
12410   register tree enumtype = NULL_TREE;
12411   struct binding_level *b = current_binding_level;
12412
12413   /* We are wasting space here and putting these on the permanent_obstack so
12414      that typeid(local enum) will work correctly. */
12415   push_obstacks (&permanent_obstack, &permanent_obstack);
12416
12417   /* If this is the real definition for a previous forward reference,
12418      fill in the contents in the same object that used to be the
12419      forward reference.  */
12420
12421   if (name != NULL_TREE)
12422     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
12423
12424   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
12425     {
12426       cp_error ("multiple definition of `%#T'", enumtype);
12427       cp_error_at ("previous definition here", enumtype);
12428     }
12429   else
12430     {
12431       enumtype = make_node (ENUMERAL_TYPE);
12432       pushtag (name, enumtype, 0);
12433     }
12434
12435   if (current_class_type)
12436     TREE_ADDRESSABLE (b->tags) = 1;
12437
12438   /* We don't copy this value because build_enumerator needs to do it.  */
12439   enum_next_value = integer_zero_node;
12440   enum_overflow = 0;
12441
12442   GNU_xref_decl (current_function_decl, enumtype);
12443   return enumtype;
12444 }
12445
12446 /* After processing and defining all the values of an enumeration type,
12447    install their decls in the enumeration type and finish it off.
12448    ENUMTYPE is the type object and VALUES a list of name-value pairs.
12449    Returns ENUMTYPE.  */
12450
12451 tree
12452 finish_enum (enumtype)
12453      tree enumtype;
12454 {
12455   register tree minnode = NULL_TREE, maxnode = NULL_TREE;
12456   /* Calculate the maximum value of any enumerator in this type.  */
12457
12458   tree values = TYPE_VALUES (enumtype);
12459   if (values)
12460     {
12461       tree pair;
12462
12463       for (pair = values; pair; pair = TREE_CHAIN (pair))
12464         {
12465           tree decl;
12466           tree value;
12467
12468           /* The TREE_VALUE is a CONST_DECL for this enumeration
12469              constant.  */
12470           decl = TREE_VALUE (pair);
12471
12472           /* The DECL_INITIAL will be NULL if we are processing a
12473              template declaration and this enumeration constant had no
12474              explicit initializer.  */
12475           value = DECL_INITIAL (decl);
12476           if (value && !processing_template_decl)
12477             {
12478               /* Set the TREE_TYPE for the VALUE as well.  That's so
12479                  that when we call decl_constant_value we get an
12480                  entity of the right type (but with the constant
12481                  value).  Since we shouldn't ever call
12482                  decl_constant_value on a template type, there's no
12483                  reason to do that when processing_template_decl.
12484                  And, if the expression is something like a
12485                  TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will
12486                  wreak havoc on the intended type of the expression.
12487
12488                  Of course, there's also no point in trying to compute
12489                  minimum or maximum values if we're in a template.  */
12490               TREE_TYPE (value) = enumtype;
12491
12492               if (!minnode)
12493                 minnode = maxnode = value;
12494               else if (tree_int_cst_lt (maxnode, value))
12495                 maxnode = value;
12496               else if (tree_int_cst_lt (value, minnode))
12497                 minnode = value;
12498             }
12499
12500           if (processing_template_decl)
12501             /* If this is just a template, leave the CONST_DECL
12502                alone.  That way tsubst_copy will find CONST_DECLs for
12503                CONST_DECLs, and not INTEGER_CSTs.  */
12504             ;
12505           else
12506             /* In the list we're building up, we want the enumeration
12507                values, not the CONST_DECLs.  */
12508             TREE_VALUE (pair) = value;
12509         }
12510     }
12511   else
12512     maxnode = minnode = integer_zero_node;
12513
12514   TYPE_VALUES (enumtype) = nreverse (values);
12515
12516   if (processing_template_decl)
12517     {
12518       tree scope = current_scope ();
12519       if (scope && TREE_CODE (scope) == FUNCTION_DECL)
12520         add_tree (build_min (TAG_DEFN, enumtype));
12521     }
12522   else
12523     {
12524       int unsignedp = tree_int_cst_sgn (minnode) >= 0;
12525       int lowprec = min_precision (minnode, unsignedp);
12526       int highprec = min_precision (maxnode, unsignedp);
12527       int precision = MAX (lowprec, highprec);
12528       tree tem;
12529
12530       TYPE_SIZE (enumtype) = NULL_TREE;
12531
12532       /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
12533
12534       TYPE_PRECISION (enumtype) = precision;
12535       if (unsignedp)
12536         fixup_unsigned_type (enumtype);
12537       else
12538         fixup_signed_type (enumtype);
12539
12540       if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
12541         /* Use the width of the narrowest normal C type which is wide
12542            enough.  */
12543         TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
12544                                                     (precision, 1));
12545       else
12546         TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
12547
12548       TYPE_SIZE (enumtype) = 0;
12549       layout_type (enumtype);
12550
12551       /* Fix up all variant types of this enum type.  */
12552       for (tem = TYPE_MAIN_VARIANT (enumtype); tem;
12553            tem = TYPE_NEXT_VARIANT (tem))
12554         {
12555           TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
12556           TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
12557           TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
12558           TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
12559           TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
12560           TYPE_MODE (tem) = TYPE_MODE (enumtype);
12561           TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
12562           TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
12563           TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
12564         }
12565
12566       /* Finish debugging output for this type.  */
12567       rest_of_type_compilation (enumtype, namespace_bindings_p ());
12568     }
12569
12570   /* In start_enum we pushed obstacks.  Here, we must pop them.  */
12571   pop_obstacks ();
12572
12573   return enumtype;
12574 }
12575
12576 /* Build and install a CONST_DECL for an enumeration constant of the
12577    enumeration type TYPE whose NAME and VALUE (if any) are provided.
12578    Assignment of sequential values by default is handled here.  */
12579
12580 tree
12581 build_enumerator (name, value, type)
12582      tree name;
12583      tree value;
12584      tree type;
12585 {
12586   tree decl, result;
12587   tree context;
12588
12589   /* Remove no-op casts from the value.  */
12590   if (value)
12591     STRIP_TYPE_NOPS (value);
12592
12593  if (! processing_template_decl)
12594    {
12595      /* Validate and default VALUE.  */
12596      if (value != NULL_TREE)
12597        {
12598          if (TREE_READONLY_DECL_P (value))
12599            value = decl_constant_value (value);
12600
12601          if (TREE_CODE (value) == INTEGER_CST)
12602            {
12603              value = default_conversion (value);
12604              constant_expression_warning (value);
12605            }
12606          else
12607            {
12608              cp_error ("enumerator value for `%D' not integer constant", name);
12609              value = NULL_TREE;
12610            }
12611        }
12612
12613      /* Default based on previous value.  */
12614      if (value == NULL_TREE && ! processing_template_decl)
12615        {
12616          value = enum_next_value;
12617          if (enum_overflow)
12618            cp_error ("overflow in enumeration values at `%D'", name);
12619        }
12620
12621      /* Remove no-op casts from the value.  */
12622      if (value)
12623        STRIP_TYPE_NOPS (value);
12624 #if 0
12625      /* To fix MAX_VAL enum consts. (bkoz)  */
12626      TREE_TYPE (value) = integer_type_node;
12627 #endif
12628    }
12629
12630  /* We always have to copy here; not all INTEGER_CSTs are unshared.
12631     Even in other cases, we will later (in finish_enum) be setting the
12632     type of VALUE.  */
12633  if (value != NULL_TREE)
12634    value = copy_node (value);
12635
12636   /* C++ associates enums with global, function, or class declarations.  */
12637
12638  context = current_scope ();
12639  if (context && context == current_class_type)
12640    /* This enum declaration is local to the class.  */
12641    decl = build_lang_decl (CONST_DECL, name, type);
12642  else
12643    /* It's a global enum, or it's local to a function.  (Note local to
12644       a function could mean local to a class method.  */
12645    decl = build_decl (CONST_DECL, name, type);
12646
12647  DECL_CONTEXT (decl) = FROB_CONTEXT (context);
12648  DECL_INITIAL (decl) = value;
12649  TREE_READONLY (decl) = 1;
12650
12651  if (context && context == current_class_type)
12652    /* In something like `struct S { enum E { i = 7 }; };' we put `i'
12653       on the TYPE_FIELDS list for `S'.  (That's so that you can say
12654       things like `S::i' later.)  */
12655    finish_member_declaration (decl);
12656  else
12657    {
12658      pushdecl (decl);
12659      GNU_xref_decl (current_function_decl, decl);
12660    }
12661
12662  if (! processing_template_decl)
12663    {
12664      /* Set basis for default for next value.  */
12665      enum_next_value = build_binary_op_nodefault (PLUS_EXPR, value,
12666                                                   integer_one_node, PLUS_EXPR);
12667      enum_overflow = tree_int_cst_lt (enum_next_value, value);
12668    }
12669
12670   result = tree_cons (name, decl, NULL_TREE);
12671   return result;
12672 }
12673
12674 \f
12675 static int function_depth;
12676
12677 /* We're defining DECL.  Make sure that it's type is OK.  */
12678
12679 static void
12680 check_function_type (decl)
12681      tree decl;
12682 {
12683   tree fntype = TREE_TYPE (decl);
12684
12685   /* In a function definition, arg types must be complete.  */
12686   require_complete_types_for_parms (current_function_parms);
12687
12688   if (TYPE_SIZE (complete_type (TREE_TYPE (fntype))) == NULL_TREE)
12689     {
12690       cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
12691
12692       /* Make it return void instead, but don't change the
12693          type of the DECL_RESULT, in case we have a named return value.  */
12694       if (TREE_CODE (fntype) == METHOD_TYPE)
12695         {
12696           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
12697           TREE_TYPE (decl)
12698             = build_cplus_method_type (ctype,
12699                                        void_type_node,
12700                                        FUNCTION_ARG_CHAIN (decl));
12701         }
12702       else
12703         TREE_TYPE (decl)
12704           = build_function_type (void_type_node,
12705                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
12706       TREE_TYPE (decl)
12707         = build_exception_variant (fntype,
12708                                    TYPE_RAISES_EXCEPTIONS (fntype));
12709     }
12710   else
12711     abstract_virtuals_error (decl, TREE_TYPE (fntype));
12712 }
12713
12714 /* Create the FUNCTION_DECL for a function definition.
12715    DECLSPECS and DECLARATOR are the parts of the declaration;
12716    they describe the function's name and the type it returns,
12717    but twisted together in a fashion that parallels the syntax of C.
12718
12719    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
12720    DECLARATOR is really the DECL for the function we are about to
12721    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
12722    indicating that the function is an inline defined in-class, and
12723    SF_EXPAND indicating that we should generate RTL for this
12724    function.
12725
12726    This function creates a binding context for the function body
12727    as well as setting up the FUNCTION_DECL in current_function_decl.
12728
12729    Returns 1 on success.  If the DECLARATOR is not suitable for a function
12730    (it defines a datum instead), we return 0, which tells
12731    yyparse to report a parse error.
12732
12733    For C++, we must first check whether that datum makes any sense.
12734    For example, "class A local_a(1,2);" means that variable local_a
12735    is an aggregate of type A, which should have a constructor
12736    applied to it with the argument list [1, 2].  */
12737
12738 int
12739 start_function (declspecs, declarator, attrs, flags)
12740      tree declspecs, declarator, attrs;
12741      int flags;
12742 {
12743   tree decl1;
12744   tree ctype = NULL_TREE;
12745   tree fntype;
12746   tree restype;
12747   extern int have_extern_spec;
12748   extern int used_extern_spec;
12749   int doing_friend = 0;
12750   struct binding_level *bl;
12751
12752   /* Sanity check.  */
12753   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
12754   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
12755
12756   /* This should only be done once on the top most decl.  */
12757   if (have_extern_spec && !used_extern_spec)
12758     {
12759       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
12760       used_extern_spec = 1;
12761     }
12762
12763   if (flags & SF_PRE_PARSED)
12764     {
12765       decl1 = declarator;
12766
12767       fntype = TREE_TYPE (decl1);
12768       if (TREE_CODE (fntype) == METHOD_TYPE)
12769         ctype = TYPE_METHOD_BASETYPE (fntype);
12770
12771       /* ANSI C++ June 5 1992 WP 11.4.5.  A friend function defined in a
12772          class is in the (lexical) scope of the class in which it is
12773          defined.  */
12774       if (!ctype && DECL_FRIEND_P (decl1))
12775         {
12776           ctype = DECL_CLASS_CONTEXT (decl1);
12777
12778           /* CTYPE could be null here if we're dealing with a template;
12779              for example, `inline friend float foo()' inside a template
12780              will have no CTYPE set.  */
12781           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
12782             ctype = NULL_TREE;
12783           else
12784             doing_friend = 1;
12785         }
12786
12787       last_function_parms = DECL_ARGUMENTS (decl1);
12788       last_function_parm_tags = NULL_TREE;
12789     }
12790   else
12791     {
12792       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL_TREE);
12793       /* If the declarator is not suitable for a function definition,
12794          cause a syntax error.  */
12795       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
12796
12797       fntype = TREE_TYPE (decl1);
12798
12799       restype = TREE_TYPE (fntype);
12800       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
12801         {
12802           cp_error ("semicolon missing after declaration of `%#T'", restype);
12803           shadow_tag (build_expr_list (NULL_TREE, restype));
12804           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
12805           if (TREE_CODE (fntype) == FUNCTION_TYPE)
12806             fntype = build_function_type (integer_type_node,
12807                                           TYPE_ARG_TYPES (fntype));
12808           else
12809             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
12810                                               integer_type_node,
12811                                               TYPE_ARG_TYPES (fntype));
12812           TREE_TYPE (decl1) = fntype;
12813         }
12814
12815       if (TREE_CODE (fntype) == METHOD_TYPE)
12816         ctype = TYPE_METHOD_BASETYPE (fntype);
12817       else if (DECL_MAIN_P (decl1))
12818         {
12819           /* If this doesn't return integer_type, complain.  */
12820           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
12821             {
12822               if (pedantic || warn_return_type)
12823                 pedwarn ("return type for `main' changed to `int'");
12824               TREE_TYPE (decl1) = fntype = default_function_type;
12825             }
12826         }
12827     }
12828
12829   /* Sometimes we don't notice that a function is a static member, and
12830      build a METHOD_TYPE for it.  Fix that up now.  */
12831   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
12832       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
12833     {
12834       revert_static_member_fn (&decl1, NULL, NULL);
12835       last_function_parms = TREE_CHAIN (last_function_parms);
12836       ctype = NULL_TREE;
12837     }
12838
12839   /* Warn if function was previously implicitly declared
12840      (but not if we warned then).  */
12841   if (! warn_implicit
12842       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
12843     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
12844
12845   /* Set up current_class_type, and enter the scope of the class, if
12846      appropriate.  */
12847   if (ctype)
12848     push_nested_class (ctype, 1);
12849   else if (DECL_STATIC_FUNCTION_P (decl1))
12850     push_nested_class (DECL_CONTEXT (decl1), 2);
12851
12852   /* Now that we have entered the scope of the class, we must restore
12853      the bindings for any template parameters surrounding DECL1, if it
12854      is an inline member template.  (Order is important; consider the
12855      case where a template parameter has the same name as a field of
12856      the class.)  It is not until after this point that
12857      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
12858   if (flags & SF_INCLASS_INLINE)
12859     maybe_begin_member_template_processing (decl1);
12860
12861   /* Effective C++ rule 15.  See also c_expand_return.  */
12862   if (warn_ecpp
12863       && DECL_NAME (decl1) == ansi_opname[(int) MODIFY_EXPR]
12864       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
12865     cp_warning ("`operator=' should return a reference to `*this'");
12866
12867   /* Make the init_value nonzero so pushdecl knows this is not tentative.
12868      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
12869   if (!DECL_INITIAL (decl1))
12870     DECL_INITIAL (decl1) = error_mark_node;
12871
12872 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
12873   SET_DEFAULT_DECL_ATTRIBUTES (decl1, attrs);
12874 #endif
12875
12876   /* This function exists in static storage.
12877      (This does not mean `static' in the C sense!)  */
12878   TREE_STATIC (decl1) = 1;
12879
12880   /* We must call push_template_decl after current_class_type is set
12881      up.  (If we are processing inline definitions after exiting a
12882      class scope, current_class_type will be NULL_TREE until set above
12883      by push_nested_class.)  */
12884   if (processing_template_decl)
12885     decl1 = push_template_decl (decl1);
12886
12887   /* We are now in the scope of the function being defined.  */
12888   current_function_decl = decl1;
12889
12890   /* Save the parm names or decls from this function's declarator
12891      where store_parm_decls will find them.  */
12892   current_function_parms = last_function_parms;
12893   current_function_parm_tags = last_function_parm_tags;
12894
12895   /* Make sure the parameter and return types are reasonable.  When
12896      you declare a function, these types can be incomplete, but they
12897      must be complete when you define the function.  */
12898   if (! processing_template_decl)
12899     check_function_type (decl1);
12900
12901   /* Build the return declaration for the function.  */
12902   restype = TREE_TYPE (fntype);
12903   if (!processing_template_decl)
12904     {
12905       if (!DECL_RESULT (decl1))
12906         {
12907           DECL_RESULT (decl1)
12908             = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
12909           c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype),
12910                                       DECL_RESULT (decl1));
12911         }
12912     }
12913   else
12914     /* Just use `void'.  Nobody will ever look at this anyhow.  */
12915     DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, void_type_node);
12916
12917   /* Initialize RTL machinery.  We cannot do this until
12918      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
12919      even when processing a template; this is how we get
12920      CURRENT_FUNCTION set up, and our per-function variables
12921      initialized.  */
12922   bl = current_binding_level;
12923   init_function_start (decl1, input_filename, lineno);
12924   current_binding_level = bl;
12925   expanding_p = (flags & SF_EXPAND) != 0;
12926
12927   /* Even though we're inside a function body, we still don't want to
12928      call expand_expr to calculate the size of a variable-sized array.
12929      We haven't necessarily assigned RTL to all variables yet, so it's
12930      not safe to try to expand expressions involving them.  */
12931   immediate_size_expand = 0;
12932   current_function->x_dont_save_pending_sizes_p = 1;
12933
12934   /* If we're building a statement-tree, start the tree now.  */
12935   if (processing_template_decl || !expanding_p)
12936     begin_stmt_tree (&DECL_SAVED_TREE (decl1));
12937
12938   /* Let the user know we're compiling this function.  */
12939   if (processing_template_decl || !building_stmt_tree ())
12940     announce_function (decl1);
12941
12942   /* Record the decl so that the function name is defined.
12943      If we already have a decl for this name, and it is a FUNCTION_DECL,
12944      use the old decl.  */
12945   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
12946     {
12947       /* A specialization is not used to guide overload resolution.  */
12948       if ((flag_guiding_decls
12949            || !DECL_TEMPLATE_SPECIALIZATION (decl1))
12950           && ! DECL_FUNCTION_MEMBER_P (decl1))
12951         decl1 = pushdecl (decl1);
12952       else
12953         {
12954           /* We need to set the DECL_CONTEXT. */
12955           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
12956             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
12957           /* And make sure we have enough default args.  */
12958           check_default_args (decl1);
12959         }
12960       DECL_MAIN_VARIANT (decl1) = decl1;
12961       fntype = TREE_TYPE (decl1);
12962     }
12963
12964   /* Reset these in case the call to pushdecl changed them.  */
12965   current_function_decl = decl1;
12966   current_function->decl = decl1;
12967
12968   /* Initialize the per-function data.  */
12969   if (!DECL_PENDING_INLINE_P (decl1) && DECL_SAVED_FUNCTION_DATA (decl1))
12970     {
12971       /* If we already parsed this function, and we're just expanding it
12972          now, restore saved state.  */
12973       struct binding_level *bl = current_binding_level;
12974       *cp_function_chain = *DECL_SAVED_FUNCTION_DATA (decl1);
12975       current_binding_level = bl;
12976
12977       /* This function is being processed in whole-function mode; we
12978          already did semantic analysis.  */
12979       current_function->x_whole_function_mode_p = 1;
12980
12981       /* If we decided that we didn't want to inline this function,
12982          make sure the back-end knows that.  */
12983       if (!current_function_cannot_inline)
12984         current_function_cannot_inline = cp_function_chain->cannot_inline;
12985
12986       /* We don't need the saved data anymore.  */
12987       free (DECL_SAVED_FUNCTION_DATA (decl1));
12988       DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
12989     }
12990   else if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
12991     {
12992       /* We know that this was set up by `grokclassfn'.  We do not
12993          wait until `store_parm_decls', since evil parse errors may
12994          never get us to that point.  Here we keep the consistency
12995          between `current_class_type' and `current_class_ptr'.  */
12996       tree t = DECL_ARGUMENTS (decl1);
12997
12998       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
12999                           162);
13000       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13001                           19990811);
13002
13003       cp_function_chain->x_current_class_ref
13004         = build_indirect_ref (t, NULL_PTR);
13005       cp_function_chain->x_current_class_ptr = t;
13006
13007       /* Constructors and destructors need to know whether they're "in
13008          charge" of initializing virtual base classes.  */
13009       if (DECL_DESTRUCTOR_P (decl1))
13010         current_in_charge_parm = TREE_CHAIN (t);
13011       else if (DECL_CONSTRUCTOR_P (decl1)
13012                && TREE_CHAIN (t)
13013                && DECL_ARTIFICIAL (TREE_CHAIN (t))
13014                && (DECL_NAME (TREE_CHAIN (t))
13015                    == in_charge_identifier))
13016         current_in_charge_parm = TREE_CHAIN (t);
13017     }
13018
13019   if (DECL_INTERFACE_KNOWN (decl1))
13020     {
13021       tree ctx = hack_decl_function_context (decl1);
13022
13023       if (DECL_NOT_REALLY_EXTERN (decl1))
13024         DECL_EXTERNAL (decl1) = 0;
13025
13026       if (ctx != NULL_TREE && DECL_THIS_INLINE (ctx)
13027           && TREE_PUBLIC (ctx))
13028         /* This is a function in a local class in an extern inline
13029            function.  */
13030         comdat_linkage (decl1);
13031     }
13032   /* If this function belongs to an interface, it is public.
13033      If it belongs to someone else's interface, it is also external.
13034      This only affects inlines and template instantiations.  */
13035   else if (interface_unknown == 0
13036            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13037                || flag_alt_external_templates))
13038     {
13039       if (DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1)
13040           || processing_template_decl)
13041         {
13042           DECL_EXTERNAL (decl1)
13043             = (interface_only
13044                || (DECL_THIS_INLINE (decl1) && ! flag_implement_inlines
13045                    && !DECL_VINDEX (decl1)));
13046
13047           /* For WIN32 we also want to put these in linkonce sections.  */
13048           maybe_make_one_only (decl1);
13049         }
13050       else
13051         DECL_EXTERNAL (decl1) = 0;
13052       DECL_NOT_REALLY_EXTERN (decl1) = 0;
13053       DECL_INTERFACE_KNOWN (decl1) = 1;
13054     }
13055   else if (interface_unknown && interface_only
13056            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13057                || flag_alt_external_templates))
13058     {
13059       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13060          interface, we will have interface_only set but not
13061          interface_known.  In that case, we don't want to use the normal
13062          heuristics because someone will supply a #pragma implementation
13063          elsewhere, and deducing it here would produce a conflict.  */
13064       comdat_linkage (decl1);
13065       DECL_EXTERNAL (decl1) = 0;
13066       DECL_INTERFACE_KNOWN (decl1) = 1;
13067       DECL_DEFER_OUTPUT (decl1) = 1;
13068     }
13069   else
13070     {
13071       /* This is a definition, not a reference.
13072          So clear DECL_EXTERNAL.  */
13073       DECL_EXTERNAL (decl1) = 0;
13074
13075       if ((DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1))
13076           && ! DECL_INTERFACE_KNOWN (decl1)
13077           /* Don't try to defer nested functions for now.  */
13078           && ! hack_decl_function_context (decl1))
13079         DECL_DEFER_OUTPUT (decl1) = 1;
13080       else
13081         DECL_INTERFACE_KNOWN (decl1) = 1;
13082     }
13083
13084   if (doing_semantic_analysis_p ())
13085     {
13086       pushlevel (0);
13087       current_binding_level->parm_flag = 1;
13088     }
13089
13090   if (attrs)
13091     cplus_decl_attributes (decl1, NULL_TREE, attrs);
13092
13093   if (!building_stmt_tree ())
13094     {
13095       GNU_xref_function (decl1, current_function_parms);
13096       make_function_rtl (decl1);
13097     }
13098
13099   /* Promote the value to int before returning it.  */
13100   if (C_PROMOTING_INTEGER_TYPE_P (restype))
13101     restype = type_promotes_to (restype);
13102
13103   /* If this fcn was already referenced via a block-scope `extern' decl
13104      (or an implicit decl), propagate certain information about the usage.  */
13105   if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1)))
13106     TREE_ADDRESSABLE (decl1) = 1;
13107
13108   if (DECL_RESULT (decl1) == NULL_TREE)
13109     {
13110       DECL_RESULT (decl1)
13111         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13112       TREE_READONLY (DECL_RESULT (decl1)) = CP_TYPE_CONST_P (restype);
13113       TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = CP_TYPE_VOLATILE_P (restype);
13114     }
13115
13116   /* Allocate further tree nodes temporarily during compilation
13117      of this function only.  Tiemann moved up here from bottom of fn.  */
13118   /* If this is a nested function, then we must continue to allocate RTL
13119      on the permanent obstack in case we need to inline it later.  */
13120   if (! hack_decl_function_context (decl1))
13121     temporary_allocation ();
13122
13123   ++function_depth;
13124
13125   if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl1))
13126       && DECL_LANGUAGE (decl1) == lang_cplusplus)
13127     dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13128   else if (DECL_CONSTRUCTOR_P (decl1))
13129     ctor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13130
13131   return 1;
13132 }
13133 \f
13134 /* Called after store_parm_decls for a function-try-block.  */
13135
13136 void
13137 expand_start_early_try_stmts ()
13138 {
13139   expand_start_try_stmts ();
13140 }
13141
13142 /* Store the parameter declarations into the current function declaration.
13143    This is called after parsing the parameter declarations, before
13144    digesting the body of the function.
13145
13146    Also install to binding contour return value identifier, if any.  */
13147
13148 void
13149 store_parm_decls ()
13150 {
13151   register tree fndecl = current_function_decl;
13152   register tree parm;
13153   int parms_have_cleanups = 0;
13154   tree cleanups = NULL_TREE;
13155
13156   /* This is a list of types declared among parms in a prototype.  */
13157   tree parmtags = current_function_parm_tags;
13158
13159   /* This is a chain of any other decls that came in among the parm
13160      declarations.  If a parm is declared with  enum {foo, bar} x;
13161      then CONST_DECLs for foo and bar are put here.  */
13162   tree nonparms = NULL_TREE;
13163
13164   /* Create a binding level for the parms.  */
13165   if (!building_stmt_tree ())
13166     expand_start_bindings (2);
13167
13168   if (current_function_parms)
13169     {
13170       /* This case is when the function was defined with an ANSI prototype.
13171          The parms already have decls, so we need not do anything here
13172          except record them as in effect
13173          and complain if any redundant old-style parm decls were written.  */
13174
13175       tree specparms = current_function_parms;
13176       tree next;
13177
13178       if (doing_semantic_analysis_p ())
13179         {
13180           /* Must clear this because it might contain TYPE_DECLs declared
13181              at class level.  */
13182           storedecls (NULL_TREE);
13183
13184           /* If we're doing semantic analysis, then we'll call pushdecl
13185              for each of these.  We must do them in reverse order so that
13186              they end in the correct forward order.  */
13187           specparms = nreverse (specparms);
13188         }
13189
13190       for (parm = specparms; parm; parm = next)
13191         {
13192           next = TREE_CHAIN (parm);
13193           if (TREE_CODE (parm) == PARM_DECL)
13194             {
13195               tree type = TREE_TYPE (parm);
13196
13197               if (doing_semantic_analysis_p ())
13198                 {
13199                   tree cleanup;
13200
13201                   if (DECL_NAME (parm) == NULL_TREE
13202                       || TREE_CODE (parm) != VOID_TYPE)
13203                     pushdecl (parm);
13204                   else
13205                     cp_error ("parameter `%D' declared void", parm);
13206
13207                   cleanup = maybe_build_cleanup (parm);
13208
13209                   if (cleanup)
13210                     cleanups = tree_cons (parm, cleanup, cleanups);
13211                 }
13212               else if (type != error_mark_node
13213                        && TYPE_NEEDS_DESTRUCTOR (type))
13214                 parms_have_cleanups = 1;
13215             }
13216           else
13217             {
13218               /* If we find an enum constant or a type tag,
13219                  put it aside for the moment.  */
13220               TREE_CHAIN (parm) = NULL_TREE;
13221               nonparms = chainon (nonparms, parm);
13222             }
13223         }
13224
13225       if (doing_semantic_analysis_p ())
13226         {
13227           /* Get the decls in their original chain order
13228              and record in the function.  This is all and only the
13229              PARM_DECLs that were pushed into scope by the loop above.  */
13230           DECL_ARGUMENTS (fndecl) = getdecls ();
13231           storetags (chainon (parmtags, gettags ()));
13232         }
13233     }
13234   else
13235     DECL_ARGUMENTS (fndecl) = NULL_TREE;
13236
13237   /* Now store the final chain of decls for the arguments
13238      as the decl-chain of the current lexical scope.
13239      Put the enumerators in as well, at the front so that
13240      DECL_ARGUMENTS is not modified.  */
13241   if (doing_semantic_analysis_p ())
13242     storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
13243
13244   /* Initialize the RTL code for the function.  */
13245   DECL_SAVED_INSNS (fndecl) = 0;
13246   if (! building_stmt_tree ())
13247     expand_function_start (fndecl, parms_have_cleanups);
13248
13249   current_function_parms_stored = 1;
13250
13251   /* If this function is `main', emit a call to `__main'
13252      to run global initializers, etc.  */
13253   if (DECL_MAIN_P (fndecl) && !building_stmt_tree ())
13254     expand_main_function ();
13255
13256   /* Now that we have initialized the parms, we can start their
13257      cleanups.  We cannot do this before, since expand_decl_cleanup
13258      should not be called before the parm can be used.  */
13259   while (cleanups)
13260     {
13261       finish_decl_cleanup (TREE_PURPOSE (cleanups),
13262                            TREE_VALUE (cleanups));
13263       cleanups = TREE_CHAIN (cleanups);
13264     }
13265
13266   /* Create a binding contour which can be used to catch
13267      cleanup-generated temporaries.  Also, if the return value needs or
13268      has initialization, deal with that now.  */
13269   if (parms_have_cleanups)
13270     {
13271       pushlevel (0);
13272       if (!building_stmt_tree ())
13273         expand_start_bindings (2);
13274     }
13275
13276   /* Do the starting of the exception specifications, if we have any.  */
13277   if (flag_exceptions && !processing_template_decl
13278       && building_stmt_tree ()
13279       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13280     current_eh_spec_try_block = expand_start_eh_spec ();
13281 }
13282
13283 /* Bind a name and initialization to the return value of
13284    the current function.  */
13285
13286 void
13287 store_return_init (decl)
13288      tree decl;
13289 {
13290   /* If this named return value comes in a register, put it in a
13291      pseudo-register.  */
13292   if (DECL_REGISTER (decl))
13293     {
13294       original_result_rtx = DECL_RTL (decl);
13295       DECL_RTL (decl) = gen_reg_rtx (DECL_MODE (decl));
13296     }
13297 }
13298
13299 \f
13300 /* We have finished doing semantic analysis on DECL, but have not yet
13301    generated RTL for its body.  Save away our current state, so that
13302    when we want to generate RTL later we know what to do.  */
13303
13304 static void
13305 save_function_data (decl)
13306      tree decl;
13307 {
13308   struct language_function *f;
13309
13310   /* Save the language-specific per-function data so that we can
13311      get it back when we really expand this function.  */
13312   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
13313                       19990908);
13314
13315   /* Make a copy.  */
13316   f = ((struct language_function *)
13317        xmalloc (sizeof (struct language_function)));
13318   bcopy ((char *) cp_function_chain, (char *) f,
13319          sizeof (struct language_function));
13320   DECL_SAVED_FUNCTION_DATA (decl) = f;
13321
13322   /* Clear out the bits we don't need.  */
13323   f->x_base_init_list = NULL_TREE;
13324   f->x_member_init_list = NULL_TREE;
13325   f->x_stmt_tree.x_last_stmt = NULL_TREE;
13326   f->x_stmt_tree.x_last_expr_type = NULL_TREE;
13327   f->x_result_rtx = NULL_RTX;
13328   f->x_named_label_uses = NULL;
13329   f->bindings = NULL;
13330
13331   /* When we get back here again, we will be expanding.  */
13332   f->x_expanding_p = 1;
13333
13334   /* If we've already decided that we cannot inline this function, we
13335      must remember that fact when we actually go to expand the
13336      function.  */
13337   f->cannot_inline = current_function_cannot_inline;
13338 }
13339
13340 /* At the end of every constructor we generate to code to return
13341    `this'.  Do that now.  */
13342
13343 static void
13344 finish_constructor_body ()
13345 {
13346   /* Any return from a constructor will end up here.  */
13347   add_tree (build_min_nt (LABEL_STMT, ctor_label));
13348
13349   /* Clear CTOR_LABEL so that finish_return_stmt knows to really
13350      generate the return, rather than a goto to CTOR_LABEL.  */
13351   ctor_label = NULL_TREE;
13352   /* In check_return_expr we translate an empty return from a
13353      constructor to a return of `this'.  */
13354   finish_return_stmt (NULL_TREE);
13355 }
13356
13357 /* At the end of every destructor we generate code to restore virtual
13358    function tables to the values desired by base classes and to call
13359    to base class destructors.  Do that now.  */
13360
13361 static void
13362 finish_destructor_body ()
13363 {
13364   tree compound_stmt;
13365   tree in_charge;
13366   tree virtual_size;
13367   tree exprstmt;
13368
13369   /* Create a block to contain all the extra code.  */
13370   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
13371
13372   /* Any return from a destructor will end up here.  */
13373   add_tree (build_min_nt (LABEL_STMT, dtor_label));
13374
13375   /* Generate the code to call destructor on base class.  If this
13376      destructor belongs to a class with virtual functions, then set
13377      the virtual function table pointer to represent the type of our
13378      base class.  */
13379
13380   /* This side-effect makes call to `build_delete' generate the code
13381      we have to have at the end of this destructor.  `build_delete'
13382      will set the flag again.  */
13383   TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
13384
13385   /* These are two cases where we cannot delegate deletion.  */
13386   if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)
13387       || TYPE_GETS_REG_DELETE (current_class_type))
13388     in_charge = integer_zero_node;
13389   else
13390     in_charge = current_in_charge_parm;
13391
13392   exprstmt = build_delete (current_class_type,
13393                            current_class_ref,
13394                            in_charge,
13395                            LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
13396                            0);
13397
13398   if (exprstmt != error_mark_node
13399       && (TREE_CODE (exprstmt) != NOP_EXPR
13400           || TREE_OPERAND (exprstmt, 0) != integer_zero_node
13401           || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
13402     {
13403       if (exprstmt != void_zero_node)
13404         /* Don't call `expand_expr_stmt' if we're not going to do
13405            anything, since -Wall will give a diagnostic.  */
13406         finish_expr_stmt (exprstmt);
13407
13408       /* Run destructors for all virtual baseclasses.  */
13409       if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
13410         {
13411           tree vbases = nreverse (copy_list (CLASSTYPE_VBASECLASSES (current_class_type)));
13412           tree if_stmt = begin_if_stmt ();
13413           finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
13414                                       current_in_charge_parm,
13415                                       integer_two_node),
13416                                if_stmt);
13417
13418           while (vbases)
13419             {
13420               if (TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (vbases)))
13421                 {
13422                   tree vb = get_vbase
13423                     (BINFO_TYPE (vbases),
13424                      TYPE_BINFO (current_class_type));
13425                   finish_expr_stmt
13426                     (build_scoped_method_call
13427                      (current_class_ref, vb, dtor_identifier,
13428                       build_expr_list (NULL_TREE, integer_zero_node)));
13429                 }
13430               vbases = TREE_CHAIN (vbases);
13431             }
13432
13433           finish_then_clause (if_stmt);
13434           finish_if_stmt ();
13435         }
13436     }
13437
13438   virtual_size = c_sizeof (current_class_type);
13439
13440   /* At the end, call delete if that's what's requested.  */
13441
13442   /* FDIS sez: At the point of definition of a virtual destructor
13443      (including an implicit definition), non-placement operator delete
13444      shall be looked up in the scope of the destructor's class and if
13445      found shall be accessible and unambiguous.
13446
13447      This is somewhat unclear, but I take it to mean that if the class
13448      only defines placement deletes we don't do anything here.  So we
13449      pass LOOKUP_SPECULATIVELY; delete_sanity will complain for us if
13450      they ever try to delete one of these.  */
13451   if (TYPE_GETS_REG_DELETE (current_class_type)
13452       || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
13453     {
13454       tree if_stmt;
13455
13456       exprstmt = build_op_delete_call
13457         (DELETE_EXPR, current_class_ptr, virtual_size,
13458          LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
13459
13460       if_stmt = begin_if_stmt ();
13461       finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
13462                                   current_in_charge_parm,
13463                                   integer_one_node),
13464                            if_stmt);
13465       finish_expr_stmt (exprstmt);
13466       finish_then_clause (if_stmt);
13467       finish_if_stmt ();
13468     }
13469
13470   /* Close the block we started above.  */
13471   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
13472 }
13473
13474 /* Finish up a function declaration and compile that function
13475    all the way to assembler language output.  The free the storage
13476    for the function definition.
13477
13478    This is called after parsing the body of the function definition.
13479    LINENO is the current line number.
13480
13481    FLAGS is a bitwise or of the following values:
13482      1 - CALL_POPLEVEL
13483        An extra call to poplevel (and expand_end_bindings) must be
13484        made to take care of the binding contour for the base
13485        initializers.  This is only relevant for constructors.
13486      2 - INCLASS_INLINE
13487        We just finished processing the body of an in-class inline
13488        function definition.  (This processing will have taken place
13489        after the class definition is complete.)  */
13490
13491 tree
13492 finish_function (lineno, flags)
13493      int lineno;
13494      int flags;
13495 {
13496   register tree fndecl = current_function_decl;
13497   tree fntype, ctype = NULL_TREE;
13498   /* Label to use if this function is supposed to return a value.  */
13499   tree no_return_label = NULL_TREE;
13500   int call_poplevel = (flags & 1) != 0;
13501   int inclass_inline = (flags & 2) != 0;
13502   int expand_p;
13503   int nested;
13504
13505   /* When we get some parse errors, we can end up without a
13506      current_function_decl, so cope.  */
13507   if (fndecl == NULL_TREE)
13508     return error_mark_node;
13509
13510   nested = function_depth > 1;
13511   fntype = TREE_TYPE (fndecl);
13512
13513   /*  TREE_READONLY (fndecl) = 1;
13514       This caused &foo to be of type ptr-to-const-function
13515       which then got a warning when stored in a ptr-to-function variable.  */
13516
13517   /* This happens on strange parse errors.  */
13518   if (! current_function_parms_stored)
13519     {
13520       call_poplevel = 0;
13521       store_parm_decls ();
13522     }
13523
13524   if (building_stmt_tree ())
13525     {
13526       if (DECL_CONSTRUCTOR_P (fndecl))
13527         {
13528           finish_constructor_body ();
13529           if (call_poplevel)
13530             do_poplevel ();
13531         }
13532       else if (DECL_DESTRUCTOR_P (fndecl) && !processing_template_decl)
13533         finish_destructor_body ();
13534       else if (DECL_MAIN_P (fndecl))
13535         {
13536           /* Make it so that `main' always returns 0 by default.  */
13537 #ifdef VMS
13538           finish_return_stmt (integer_one_node);
13539 #else
13540           finish_return_stmt (integer_zero_node);
13541 #endif
13542         }
13543
13544       /* Finish dealing with exception specifiers.  */
13545       if (flag_exceptions && !processing_template_decl
13546           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13547         expand_end_eh_spec (TYPE_RAISES_EXCEPTIONS
13548                             (TREE_TYPE (current_function_decl)),
13549                             current_eh_spec_try_block);
13550     }
13551   else
13552     {
13553       if (write_symbols != NO_DEBUG /*&& TREE_CODE (fntype) != METHOD_TYPE*/)
13554         {
13555           tree ttype = target_type (fntype);
13556           tree parmdecl;
13557
13558           if (IS_AGGR_TYPE (ttype))
13559             /* Let debugger know it should output info for this type.  */
13560             note_debug_info_needed (ttype);
13561
13562           for (parmdecl = DECL_ARGUMENTS (fndecl); parmdecl; parmdecl = TREE_CHAIN (parmdecl))
13563             {
13564               ttype = target_type (TREE_TYPE (parmdecl));
13565               if (IS_AGGR_TYPE (ttype))
13566                 /* Let debugger know it should output info for this type.  */
13567                 note_debug_info_needed (ttype);
13568             }
13569         }
13570
13571       /* Clean house because we will need to reorder insns here.  */
13572       do_pending_stack_adjust ();
13573
13574       if (dtor_label)
13575         ;
13576       else if (DECL_CONSTRUCTOR_P (fndecl))
13577         {
13578           /* All subobjects have been fully constructed at this point.  */
13579           end_protect_partials ();
13580
13581           if (call_poplevel)
13582             do_poplevel ();
13583         }
13584       else if (return_label != NULL_RTX
13585                && flag_this_is_variable <= 0
13586                && current_function_return_value == NULL_TREE
13587                && ! DECL_NAME (DECL_RESULT (current_function_decl)))
13588         no_return_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13589
13590       if (flag_exceptions)
13591         expand_exception_blocks ();
13592
13593       /* If this function is supposed to return a value, ensure that
13594          we do not fall into the cleanups by mistake.  The end of our
13595          function will look like this:
13596
13597          user code (may have return stmt somewhere)
13598          goto no_return_label
13599          cleanup_label:
13600          cleanups
13601          goto return_label
13602          no_return_label:
13603          NOTE_INSN_FUNCTION_END
13604          return_label:
13605          things for return
13606
13607          If the user omits a return stmt in the USER CODE section, we
13608          will have a control path which reaches NOTE_INSN_FUNCTION_END.
13609          Otherwise, we won't.  */
13610       if (no_return_label)
13611         {
13612           DECL_CONTEXT (no_return_label) = fndecl;
13613           DECL_INITIAL (no_return_label) = error_mark_node;
13614           DECL_SOURCE_FILE (no_return_label) = input_filename;
13615           DECL_SOURCE_LINE (no_return_label) = lineno;
13616           expand_goto (no_return_label);
13617         }
13618
13619       if (cleanup_label)
13620         {
13621           /* Remove the binding contour which is used
13622              to catch cleanup-generated temporaries.  */
13623           expand_end_bindings (0, 0, 0);
13624           poplevel (0, 0, 0);
13625
13626           /* Emit label at beginning of cleanup code for parameters.  */
13627           emit_label (cleanup_label);
13628         }
13629
13630       /* Get return value into register if that's where it's supposed
13631          to be.  */
13632       if (original_result_rtx)
13633         fixup_result_decl (DECL_RESULT (fndecl), original_result_rtx);
13634
13635       /* Finish building code that will trigger warnings if users forget
13636          to make their functions return values.  */
13637       if (no_return_label || cleanup_label)
13638         emit_jump (return_label);
13639       if (no_return_label)
13640         {
13641           /* We don't need to call `expand_*_return' here because we
13642              don't need any cleanups here--this path of code is only
13643              for error checking purposes.  */
13644           expand_label (no_return_label);
13645         }
13646
13647       /* We hard-wired immediate_size_expand to zero in
13648          start_function.  Expand_function_end will decrement this
13649          variable.  So, we set the variable to one here, so that after
13650          the decrement it will remain zero.  */
13651       immediate_size_expand = 1;
13652
13653       /* Generate rtl for function exit.  */
13654       expand_function_end (input_filename, lineno, 1);
13655     }
13656
13657   /* We have to save this value here in case
13658      maybe_end_member_template_processing decides to pop all the
13659      template parameters.  */
13660   expand_p = !building_stmt_tree ();
13661
13662   /* If we're saving up tree structure, tie off the function now.  */
13663   if (!expand_p)
13664     finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
13665
13666   /* This must come after expand_function_end because cleanups might
13667      have declarations (from inline functions) that need to go into
13668      this function's blocks.  */
13669   if (doing_semantic_analysis_p ())
13670     {
13671       if (current_binding_level->parm_flag != 1)
13672         my_friendly_abort (122);
13673       poplevel (1, 0, 1);
13674     }
13675
13676   /* Remember that we were in class scope.  */
13677   if (current_class_name)
13678     ctype = current_class_type;
13679
13680   /* Must mark the RESULT_DECL as being in this function.  */
13681   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
13682
13683   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
13684      to the FUNCTION_DECL node itself.  */
13685   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
13686
13687   /* Save away current state, if appropriate.  */
13688   if (!expanding_p && !processing_template_decl)
13689     save_function_data (fndecl);
13690
13691   if (expand_p)
13692     {
13693       int returns_null;
13694       int returns_value;
13695       int saved_flag_keep_inline_functions =
13696         flag_keep_inline_functions;
13697
13698       /* So we can tell if jump_optimize sets it to 1.  */
13699       can_reach_end = 0;
13700
13701       if (DECL_CONTEXT (fndecl) != NULL_TREE
13702           && hack_decl_function_context (fndecl))
13703         /* Trick rest_of_compilation into not deferring output of this
13704            function, even if it is inline, since the rtl_obstack for
13705            this function is the function_obstack of the enclosing
13706            function and will be deallocated when the enclosing
13707            function is gone.  See save_tree_status.  */
13708         flag_keep_inline_functions = 1;
13709
13710       /* Before we call rest_of_compilation (which will pop the
13711          CURRENT_FUNCTION), we must save these values.  */
13712       returns_null = current_function_returns_null;
13713       returns_value = current_function_returns_value;
13714
13715       /* If this is a nested function (like a template instantiation
13716          that we're compiling in the midst of compiling something
13717          else), push a new GC context.  That will keep local variables
13718          on the stack from being collected while we're doing the
13719          compilation of this function.  */
13720       if (function_depth > 1)
13721         ggc_push_context ();
13722
13723       /* Run the optimizers and output the assembler code for this
13724          function.  */
13725       if (DECL_ARTIFICIAL (fndecl))
13726         {
13727           /* Do we really *want* to inline this synthesized method?  */
13728
13729           int save_fif = flag_inline_functions;
13730           flag_inline_functions = 1;
13731
13732           /* Turn off DECL_INLINE for the moment so function_cannot_inline_p
13733              will check our size.  */
13734           DECL_INLINE (fndecl) = 0;
13735
13736           rest_of_compilation (fndecl);
13737           flag_inline_functions = save_fif;
13738         }
13739       else
13740         rest_of_compilation (fndecl);
13741
13742       /* Undo the call to ggc_push_context above.  */
13743       if (function_depth > 1)
13744         ggc_pop_context ();
13745
13746       flag_keep_inline_functions = saved_flag_keep_inline_functions;
13747
13748       if (DECL_SAVED_INSNS (fndecl) && ! TREE_ASM_WRITTEN (fndecl))
13749         {
13750           /* Set DECL_EXTERNAL so that assemble_external will be called as
13751              necessary.  We'll clear it again in finish_file.  */
13752           if (! DECL_EXTERNAL (fndecl))
13753             DECL_NOT_REALLY_EXTERN (fndecl) = 1;
13754           DECL_EXTERNAL (fndecl) = 1;
13755           mark_inline_for_output (fndecl);
13756         }
13757
13758       if (ctype && TREE_ASM_WRITTEN (fndecl))
13759         note_debug_info_needed (ctype);
13760
13761       returns_null |= can_reach_end;
13762
13763       /* Since we don't normally go through c_expand_return for constructors,
13764          this normally gets the wrong value.
13765          Also, named return values have their return codes emitted after
13766          NOTE_INSN_FUNCTION_END, confusing jump.c.  */
13767       if (DECL_CONSTRUCTOR_P (fndecl)
13768           || DECL_NAME (DECL_RESULT (fndecl)) != NULL_TREE)
13769         returns_null = 0;
13770
13771       if (TREE_THIS_VOLATILE (fndecl) && returns_null)
13772         cp_warning ("`noreturn' function `%D' does return", fndecl);
13773       else if ((warn_return_type || pedantic)
13774                && returns_null
13775                && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE)
13776         {
13777           /* If this function returns non-void and control can drop through,
13778              complain.  */
13779           cp_warning ("control reaches end of non-void function `%D'", fndecl);
13780         }
13781       /* With just -W, complain only if function returns both with
13782          and without a value.  */
13783       else if (extra_warnings && returns_value && returns_null)
13784         warning ("this function may return with or without a value");
13785     }
13786   else
13787     {
13788       /* Clear out memory we no longer need.  */
13789       free_after_parsing (current_function);
13790       /* Since we never call rest_of_compilation, we never clear
13791          CURRENT_FUNCTION.  Do so explicitly.  */
13792       free_after_compilation (current_function);
13793       current_function = NULL;
13794     }
13795
13796   /* If this is a in-class inline definition, we may have to pop the
13797      bindings for the template parameters that we added in
13798      maybe_begin_member_template_processing when start_function was
13799      called.  */
13800   if (inclass_inline)
13801     maybe_end_member_template_processing ();
13802
13803   /* Leave the scope of the class.  */
13804   if (ctype)
13805     pop_nested_class ();
13806
13807   --function_depth;
13808
13809   /* Free all the tree nodes making up this function.  */
13810   /* Switch back to allocating nodes permanently
13811      until we start another function.  */
13812   if (! nested)
13813     permanent_allocation (1);
13814
13815   if (!DECL_SAVED_INSNS (fndecl) && !DECL_SAVED_FUNCTION_DATA (fndecl))
13816     {
13817       tree t;
13818
13819       /* Stop pointing to the local nodes about to be freed.  */
13820       /* But DECL_INITIAL must remain nonzero so we know this
13821          was an actual function definition.  */
13822       DECL_INITIAL (fndecl) = error_mark_node;
13823       for (t = DECL_ARGUMENTS (fndecl); t; t = TREE_CHAIN (t))
13824         DECL_RTL (t) = DECL_INCOMING_RTL (t) = NULL_RTX;
13825     }
13826
13827   if (DECL_STATIC_CONSTRUCTOR (fndecl))
13828     static_ctors = tree_cons (NULL_TREE, fndecl, static_ctors);
13829   if (DECL_STATIC_DESTRUCTOR (fndecl))
13830     static_dtors = tree_cons (NULL_TREE, fndecl, static_dtors);
13831
13832   /* Clean up.  */
13833   if (! nested)
13834     {
13835       /* Let the error reporting routines know that we're outside a
13836          function.  For a nested function, this value is used in
13837          pop_cp_function_context and then reset via pop_function_context.  */
13838       current_function_decl = NULL_TREE;
13839     }
13840
13841   return fndecl;
13842 }
13843 \f
13844 /* Create the FUNCTION_DECL for a function definition.
13845    DECLSPECS and DECLARATOR are the parts of the declaration;
13846    they describe the return type and the name of the function,
13847    but twisted together in a fashion that parallels the syntax of C.
13848
13849    This function creates a binding context for the function body
13850    as well as setting up the FUNCTION_DECL in current_function_decl.
13851
13852    Returns a FUNCTION_DECL on success.
13853
13854    If the DECLARATOR is not suitable for a function (it defines a datum
13855    instead), we return 0, which tells yyparse to report a parse error.
13856
13857    May return void_type_node indicating that this method is actually
13858    a friend.  See grokfield for more details.
13859
13860    Came here with a `.pushlevel' .
13861
13862    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
13863    CHANGES TO CODE IN `grokfield'.  */
13864
13865 tree
13866 start_method (declspecs, declarator, attrlist)
13867      tree declarator, declspecs, attrlist;
13868 {
13869   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
13870                                 attrlist);
13871
13872   /* Something too ugly to handle.  */
13873   if (fndecl == NULL_TREE)
13874     return NULL_TREE;
13875
13876   /* Pass friends other than inline friend functions back.  */
13877   if (fndecl == void_type_node)
13878     return fndecl;
13879
13880   if (TREE_CODE (fndecl) != FUNCTION_DECL)
13881     /* Not a function, tell parser to report parse error.  */
13882     return NULL_TREE;
13883
13884   if (DECL_IN_AGGR_P (fndecl))
13885     {
13886       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
13887         {
13888           if (DECL_CONTEXT (fndecl)
13889               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
13890             cp_error ("`%D' is already defined in class %s", fndecl,
13891                              TYPE_NAME_STRING (DECL_CONTEXT (fndecl)));
13892         }
13893       return void_type_node;
13894     }
13895
13896   check_template_shadow (fndecl);
13897
13898   DECL_THIS_INLINE (fndecl) = 1;
13899
13900   if (flag_default_inline)
13901     DECL_INLINE (fndecl) = 1;
13902
13903   /* We process method specializations in finish_struct_1.  */
13904   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
13905     fndecl = push_template_decl (fndecl);
13906
13907   /* We read in the parameters on the maybepermanent_obstack,
13908      but we won't be getting back to them until after we
13909      may have clobbered them.  So the call to preserve_data
13910      will keep them safe.  */
13911   preserve_data ();
13912
13913   if (! DECL_FRIEND_P (fndecl))
13914     {
13915       if (TREE_CHAIN (fndecl))
13916         {
13917           fndecl = copy_node (fndecl);
13918           TREE_CHAIN (fndecl) = NULL_TREE;
13919         }
13920
13921       if (DECL_CONSTRUCTOR_P (fndecl))
13922         {
13923           if (! grok_ctor_properties (current_class_type, fndecl))
13924             return void_type_node;
13925         }
13926       else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl)))
13927         grok_op_properties (fndecl, DECL_VIRTUAL_P (fndecl), 0);
13928     }
13929
13930   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0, 0);
13931
13932   /* Make a place for the parms */
13933   pushlevel (0);
13934   current_binding_level->parm_flag = 1;
13935
13936   DECL_IN_AGGR_P (fndecl) = 1;
13937   return fndecl;
13938 }
13939
13940 /* Go through the motions of finishing a function definition.
13941    We don't compile this method until after the whole class has
13942    been processed.
13943
13944    FINISH_METHOD must return something that looks as though it
13945    came from GROKFIELD (since we are defining a method, after all).
13946
13947    This is called after parsing the body of the function definition.
13948    STMTS is the chain of statements that makes up the function body.
13949
13950    DECL is the ..._DECL that `start_method' provided.  */
13951
13952 tree
13953 finish_method (decl)
13954      tree decl;
13955 {
13956   register tree fndecl = decl;
13957   tree old_initial;
13958
13959   register tree link;
13960
13961   if (decl == void_type_node)
13962     return decl;
13963
13964   old_initial = DECL_INITIAL (fndecl);
13965
13966   /* Undo the level for the parms (from start_method).
13967      This is like poplevel, but it causes nothing to be
13968      saved.  Saving information here confuses symbol-table
13969      output routines.  Besides, this information will
13970      be correctly output when this method is actually
13971      compiled.  */
13972
13973   /* Clear out the meanings of the local variables of this level;
13974      also record in each decl which block it belongs to.  */
13975
13976   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
13977     {
13978       if (DECL_NAME (link) != NULL_TREE)
13979         pop_binding (DECL_NAME (link), link);
13980       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
13981       DECL_CONTEXT (link) = NULL_TREE;
13982     }
13983
13984   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
13985                       (HOST_WIDE_INT) current_binding_level->level_chain,
13986                       current_binding_level->parm_flag,
13987                       current_binding_level->keep);
13988
13989   poplevel (0, 0, 0);
13990
13991   DECL_INITIAL (fndecl) = old_initial;
13992
13993   /* We used to check if the context of FNDECL was different from
13994      current_class_type as another way to get inside here.  This didn't work
13995      for String.cc in libg++.  */
13996   if (DECL_FRIEND_P (fndecl))
13997     {
13998       CLASSTYPE_INLINE_FRIENDS (current_class_type)
13999         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14000       decl = void_type_node;
14001     }
14002
14003   return decl;
14004 }
14005 \f
14006 /* Called when a new struct TYPE is defined.
14007    If this structure or union completes the type of any previous
14008    variable declaration, lay it out and output its rtl.  */
14009
14010 void
14011 hack_incomplete_structures (type)
14012      tree type;
14013 {
14014   tree *list;
14015
14016   if (current_binding_level->incomplete == NULL_TREE)
14017     return;
14018
14019   if (!type) /* Don't do this for class templates.  */
14020     return;
14021
14022   for (list = &current_binding_level->incomplete; *list; )
14023     {
14024       tree decl = TREE_VALUE (*list);
14025       if ((decl && TREE_TYPE (decl) == type)
14026           || (TREE_TYPE (decl)
14027               && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14028               && TREE_TYPE (TREE_TYPE (decl)) == type))
14029         {
14030           int toplevel = toplevel_bindings_p ();
14031           if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14032               && TREE_TYPE (TREE_TYPE (decl)) == type)
14033             layout_type (TREE_TYPE (decl));
14034           layout_decl (decl, 0);
14035           rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
14036           if (! toplevel)
14037             {
14038               tree cleanup;
14039               expand_decl (decl);
14040               cleanup = maybe_build_cleanup (decl);
14041               expand_decl_init (decl);
14042               if (! expand_decl_cleanup (decl, cleanup))
14043                 cp_error ("parser lost in parsing declaration of `%D'",
14044                           decl);
14045             }
14046           *list = TREE_CHAIN (*list);
14047         }
14048       else
14049         list = &TREE_CHAIN (*list);
14050     }
14051 }
14052
14053 /* If DECL is of a type which needs a cleanup, build that cleanup here.
14054    See build_delete for information about AUTO_DELETE.
14055
14056    Don't build these on the momentary obstack; they must live
14057    the life of the binding contour.  */
14058
14059 static tree
14060 maybe_build_cleanup_1 (decl, auto_delete)
14061      tree decl, auto_delete;
14062 {
14063   tree type = TREE_TYPE (decl);
14064   if (type != error_mark_node && TYPE_NEEDS_DESTRUCTOR (type))
14065     {
14066       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14067       tree rval;
14068
14069       if (TREE_CODE (type) == ARRAY_TYPE)
14070         rval = decl;
14071       else
14072         {
14073           mark_addressable (decl);
14074           rval = build_unary_op (ADDR_EXPR, decl, 0);
14075         }
14076
14077       /* Optimize for space over speed here.  */
14078       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14079           || flag_expensive_optimizations)
14080         flags |= LOOKUP_NONVIRTUAL;
14081
14082       rval = build_delete (TREE_TYPE (rval), rval, auto_delete, flags, 0);
14083
14084       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14085           && ! TYPE_HAS_DESTRUCTOR (type))
14086         rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14087                                                build_expr_list (NULL_TREE, build_vbase_delete (type, decl))));
14088
14089       return rval;
14090     }
14091   return 0;
14092 }
14093
14094 /* Build a TARGET_EXPR, initializing the DECL with the VALUE.  */
14095
14096 tree
14097 build_target_expr (decl, value)
14098      tree decl;
14099      tree value;
14100 {
14101   tree t;
14102
14103   t = build (TARGET_EXPR, TREE_TYPE (decl), decl, value,
14104              maybe_build_cleanup (decl), NULL_TREE);
14105   /* We always set TREE_SIDE_EFFECTS so that expand_expr does not
14106      ignore the TARGET_EXPR.  If there really turn out to be no
14107      side-effects, then the optimizer should be able to get rid of
14108      whatever code is generated anyhow.  */
14109   TREE_SIDE_EFFECTS (t) = 1;
14110
14111   return t;
14112 }
14113
14114 /* If DECL is of a type which needs a cleanup, build that cleanup
14115    here.  The cleanup does free the storage with a call to delete.  */
14116
14117 tree
14118 maybe_build_cleanup_and_delete (decl)
14119      tree decl;
14120 {
14121   return maybe_build_cleanup_1 (decl, integer_three_node);
14122 }
14123
14124 /* If DECL is of a type which needs a cleanup, build that cleanup
14125    here.  The cleanup does not free the storage with a call a delete.  */
14126
14127 tree
14128 maybe_build_cleanup (decl)
14129      tree decl;
14130 {
14131   return maybe_build_cleanup_1 (decl, integer_two_node);
14132 }
14133 \f
14134 /* Expand a C++ expression at the statement level.
14135    This is needed to ferret out nodes which have UNKNOWN_TYPE.
14136    The C++ type checker should get all of these out when
14137    expressions are combined with other, type-providing, expressions,
14138    leaving only orphan expressions, such as:
14139
14140    &class::bar;         / / takes its address, but does nothing with it.  */
14141
14142 void
14143 cplus_expand_expr_stmt (exp)
14144      tree exp;
14145 {
14146   if (stmts_are_full_exprs_p)
14147     exp = convert_to_void (exp, "statement");
14148
14149 #if 0
14150   /* We should do this eventually, but right now this causes regex.o from
14151      libg++ to miscompile, and tString to core dump.  */
14152   exp = build1 (CLEANUP_POINT_EXPR, TREE_TYPE (exp), exp);
14153 #endif
14154
14155   /* If we don't do this, we end up down inside expand_expr
14156      trying to do TYPE_MODE on the ERROR_MARK, and really
14157      go outside the bounds of the type.  */
14158   if (exp != error_mark_node)
14159     expand_expr_stmt (exp);
14160 }
14161
14162 /* When a stmt has been parsed, this function is called.  */
14163
14164 void
14165 finish_stmt ()
14166 {
14167   /* Always assume this statement was not an expression statement.  If
14168      it actually was an expression statement, its our callers
14169      responsibility to fix this up.  */
14170   last_expr_type = NULL_TREE;
14171 }
14172
14173 /* Change a static member function definition into a FUNCTION_TYPE, instead
14174    of the METHOD_TYPE that we create when it's originally parsed.
14175
14176    WARNING: DO NOT pass &TREE_TYPE (decl) to FN or &TYPE_ARG_TYPES
14177    (TREE_TYPE (decl)) to ARGTYPES, as doing so will corrupt the types of
14178    other decls.  Either pass the addresses of local variables or NULL.  */
14179
14180 void
14181 revert_static_member_fn (decl, fn, argtypes)
14182      tree *decl, *fn, *argtypes;
14183 {
14184   tree tmp;
14185   tree function = fn ? *fn : TREE_TYPE (*decl);
14186   tree args = argtypes ? *argtypes : TYPE_ARG_TYPES (function);
14187
14188   if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args)))
14189       != TYPE_UNQUALIFIED)
14190     cp_error ("static member function `%#D' declared with type qualifiers",
14191               *decl);
14192
14193   args = TREE_CHAIN (args);
14194   tmp = build_function_type (TREE_TYPE (function), args);
14195   tmp = build_qualified_type (tmp, CP_TYPE_QUALS (function));
14196   tmp = build_exception_variant (tmp,
14197                                  TYPE_RAISES_EXCEPTIONS (function));
14198   TREE_TYPE (*decl) = tmp;
14199   if (DECL_ARGUMENTS (*decl))
14200     DECL_ARGUMENTS (*decl) = TREE_CHAIN (DECL_ARGUMENTS (*decl));
14201   DECL_STATIC_FUNCTION_P (*decl) = 1;
14202   if (fn)
14203     *fn = tmp;
14204   if (argtypes)
14205     *argtypes = args;
14206 }
14207
14208 /* Initialize the variables used during compilation of a C++
14209    function.  */
14210
14211 static void
14212 push_cp_function_context (f)
14213      struct function *f;
14214 {
14215   struct language_function *p
14216     = ((struct language_function *)
14217        xcalloc (1, sizeof (struct language_function)));
14218   f->language = p;
14219
14220   /* It takes an explicit call to expand_body to generate RTL for a
14221      function.  */
14222   expanding_p = 0;
14223
14224   /* Whenever we start a new function, we destroy temporaries in the
14225      usual way.  */
14226   stmts_are_full_exprs_p = 1;
14227 }
14228
14229 /* Free the language-specific parts of F, now that we've finished
14230    compiling the function.  */
14231
14232 static void
14233 pop_cp_function_context (f)
14234      struct function *f;
14235 {
14236   if (f->language)
14237     free (f->language);
14238   f->language = 0;
14239 }
14240
14241 /* Mark P for GC.  */
14242
14243 static void
14244 mark_lang_function (p)
14245      struct language_function *p;
14246 {
14247   if (!p)
14248     return;
14249
14250   ggc_mark_tree (p->x_named_labels);
14251   ggc_mark_tree (p->x_ctor_label);
14252   ggc_mark_tree (p->x_dtor_label);
14253   ggc_mark_tree (p->x_base_init_list);
14254   ggc_mark_tree (p->x_member_init_list);
14255   ggc_mark_tree (p->x_current_class_ptr);
14256   ggc_mark_tree (p->x_current_class_ref);
14257   ggc_mark_tree (p->x_eh_spec_try_block);
14258   ggc_mark_tree (p->x_scope_stmt_stack);
14259
14260   ggc_mark_rtx (p->x_result_rtx);
14261
14262   mark_stmt_tree (&p->x_stmt_tree);
14263   mark_binding_level (&p->bindings);
14264 }
14265
14266 /* Mark the language-specific data in F for GC.  */
14267
14268 void
14269 mark_cp_function_context (f)
14270      struct function *f;
14271 {
14272   mark_lang_function (f->language);
14273 }
14274
14275 int
14276 in_function_p ()
14277 {
14278   return function_depth != 0;
14279 }
14280
14281
14282 void
14283 lang_mark_false_label_stack (l)
14284      struct label_node *l;
14285 {
14286   /* C++ doesn't use false_label_stack.  It better be NULL.  */
14287   my_friendly_assert (l == NULL, 19990904);
14288 }
14289
14290 void
14291 lang_mark_tree (t)
14292      tree t;
14293 {
14294   enum tree_code code = TREE_CODE (t);
14295   if (code == IDENTIFIER_NODE)
14296     {
14297       struct lang_identifier *li = (struct lang_identifier *) t;
14298       struct lang_id2 *li2 = li->x;
14299       ggc_mark_tree (li->namespace_bindings);
14300       ggc_mark_tree (li->bindings);
14301       ggc_mark_tree (li->class_value);
14302       ggc_mark_tree (li->class_template_info);
14303
14304       if (li2)
14305         {
14306           ggc_mark_tree (li2->label_value);
14307           ggc_mark_tree (li2->implicit_decl);
14308           ggc_mark_tree (li2->error_locus);
14309         }
14310     }
14311   else if (code == CPLUS_BINDING)
14312     {
14313       if (BINDING_HAS_LEVEL_P (t))
14314         mark_binding_level (&BINDING_LEVEL (t));
14315       else
14316         ggc_mark_tree (BINDING_SCOPE (t));
14317       ggc_mark_tree (BINDING_VALUE (t));
14318     }
14319   else if (code == OVERLOAD)
14320     ggc_mark_tree (OVL_FUNCTION (t));
14321   else if (code == TEMPLATE_PARM_INDEX)
14322     ggc_mark_tree (TEMPLATE_PARM_DECL (t));
14323   else if (TREE_CODE_CLASS (code) == 'd')
14324     {
14325       struct lang_decl *ld = DECL_LANG_SPECIFIC (t);
14326
14327       if (ld)
14328         {
14329           ggc_mark (ld);
14330           if (!DECL_GLOBAL_CTOR_P (t) && !DECL_GLOBAL_DTOR_P (t))
14331             ggc_mark_tree (ld->decl_flags.u2.access);
14332           ggc_mark_tree (ld->decl_flags.context);
14333           if (TREE_CODE (t) != NAMESPACE_DECL)
14334             ggc_mark_tree (ld->decl_flags.u.template_info);
14335           else
14336             mark_binding_level (&NAMESPACE_LEVEL (t));
14337           if (CAN_HAVE_FULL_LANG_DECL_P (t))
14338             {
14339               ggc_mark_tree (ld->main_decl_variant);
14340               ggc_mark_tree (ld->befriending_classes);
14341               ggc_mark_tree (ld->saved_tree);
14342               if (TREE_CODE (t) == TYPE_DECL)
14343                 ggc_mark_tree (ld->u.sorted_fields);
14344               else if (TREE_CODE (t) == FUNCTION_DECL
14345                        && !DECL_PENDING_INLINE_P (t))
14346                 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t));
14347             }
14348         }
14349     }
14350   else if (TREE_CODE_CLASS (code) == 't')
14351     {
14352       struct lang_type *lt = TYPE_LANG_SPECIFIC (t);
14353
14354       if (lt && !(TREE_CODE (t) == POINTER_TYPE
14355                   && TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE))
14356         {
14357           ggc_mark (lt);
14358           ggc_mark_tree (lt->vfields);
14359           ggc_mark_tree (lt->vbases);
14360           ggc_mark_tree (lt->tags);
14361           ggc_mark_tree (lt->search_slot);
14362           ggc_mark_tree (lt->size);
14363           ggc_mark_tree (lt->abstract_virtuals);
14364           ggc_mark_tree (lt->friend_classes);
14365           ggc_mark_tree (lt->rtti);
14366           ggc_mark_tree (lt->methods);
14367           ggc_mark_tree (lt->template_info);
14368           ggc_mark_tree (lt->befriending_classes);
14369         }
14370       else if (lt)
14371         /* In the case of pointer-to-member function types, the
14372            TYPE_LANG_SPECIFIC is really just a tree.  */
14373         ggc_mark_tree ((tree) lt);
14374     }
14375 }
14376