gcc/cp/decl.c

   1 /* Process declarations and variables for C compiler.
   2    Copyright (C) 1988, 92-98, 1999, 2000 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
  53 extern int current_class_depth;
  54
  55 extern tree static_ctors, static_dtors;
  56
  57 extern tree global_namespace;
  58
  59 extern int (*valid_lang_attribute) PARAMS ((tree, tree, tree, tree));
  60
  61 /* Use garbage collection.  */
  62
  63 int ggc_p = 1;
  64
  65 #ifndef WCHAR_UNSIGNED
  66 #define WCHAR_UNSIGNED 0
  67 #endif
  68
  69 #ifndef CHAR_TYPE_SIZE
  70 #define CHAR_TYPE_SIZE BITS_PER_UNIT
  71 #endif
  72
  73 #ifndef BOOL_TYPE_SIZE
  74 #ifdef SLOW_BYTE_ACCESS
  75 /* In the new ABI, `bool' has size and alignment `1', on all
  76    platforms.  */
  77 #define BOOL_TYPE_SIZE \
  78   ((SLOW_BYTE_ACCESS && !flag_new_abi) ? (POINTER_SIZE) : (CHAR_TYPE_SIZE))
  79 #else
  80 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
  81 #endif
  82 #endif
  83
  84 /* We let tm.h override the types used here, to handle trivial differences
  85    such as the choice of unsigned int or long unsigned int for size_t.
  86    When machines start needing nontrivial differences in the size type,
  87    it would be best to do something here to figure out automatically
  88    from other information what type to use.  */
  89
  90 #ifndef SIZE_TYPE
  91 #define SIZE_TYPE "long unsigned int"
  92 #endif
  93
  94 #ifndef PTRDIFF_TYPE
  95 #define PTRDIFF_TYPE "long int"
  96 #endif
  97
  98 #ifndef WCHAR_TYPE
  99 #define WCHAR_TYPE "int"
 100 #endif
 101
 102 static tree grokparms                           PARAMS ((tree, int));
 103 static const char *redeclaration_error_message  PARAMS ((tree, tree));
 104
 105 static void push_binding_level PARAMS ((struct binding_level *, int,
 106                                       int));
 107 static void pop_binding_level PARAMS ((void));
 108 static void suspend_binding_level PARAMS ((void));
 109 static void resume_binding_level PARAMS ((struct binding_level *));
 110 static struct binding_level *make_binding_level PARAMS ((void));
 111 static void declare_namespace_level PARAMS ((void));
 112 static void signal_catch PARAMS ((int)) ATTRIBUTE_NORETURN;
 113 static void storedecls PARAMS ((tree));
 114 static void require_complete_types_for_parms PARAMS ((tree));
 115 static void push_overloaded_decl_1 PARAMS ((tree));
 116 static int ambi_op_p PARAMS ((tree));
 117 static int unary_op_p PARAMS ((tree));
 118 static tree store_bindings PARAMS ((tree, tree));
 119 static tree lookup_tag_reverse PARAMS ((tree, tree));
 120 static tree obscure_complex_init PARAMS ((tree, tree));
 121 static tree maybe_build_cleanup_1 PARAMS ((tree, tree));
 122 static tree lookup_name_real PARAMS ((tree, int, int, int));
 123 static void warn_extern_redeclared_static PARAMS ((tree, tree));
 124 static void grok_reference_init PARAMS ((tree, tree, tree));
 125 static tree grokfndecl PARAMS ((tree, tree, tree, tree, int,
 126                               enum overload_flags, tree,
 127                               tree, int, int, int, int, int, int, tree));
 128 static tree grokvardecl PARAMS ((tree, tree, RID_BIT_TYPE *, int, int, tree));
 129 static tree lookup_tag PARAMS ((enum tree_code, tree,
 130                               struct binding_level *, int));
 131 static void set_identifier_type_value_with_scope
 132         PARAMS ((tree, tree, struct binding_level *));
 133 static void record_builtin_type PARAMS ((enum rid, const char *, tree));
 134 static void record_unknown_type PARAMS ((tree, const char *));
 135 static int member_function_or_else PARAMS ((tree, tree, enum overload_flags));
 136 static void bad_specifiers PARAMS ((tree, const char *, int, int, int, int,
 137                                   int));
 138 static void lang_print_error_function PARAMS ((const char *));
 139 static tree maybe_process_template_type_declaration PARAMS ((tree, int, struct binding_level*));
 140 static void check_for_uninitialized_const_var PARAMS ((tree));
 141 static unsigned long typename_hash PARAMS ((hash_table_key));
 142 static boolean typename_compare PARAMS ((hash_table_key, hash_table_key));
 143 static void push_binding PARAMS ((tree, tree, struct binding_level*));
 144 static int add_binding PARAMS ((tree, tree));
 145 static void pop_binding PARAMS ((tree, tree));
 146 static tree local_variable_p_walkfn PARAMS ((tree *, int *, void *));
 147 static tree find_binding PARAMS ((tree, tree));
 148 static tree select_decl PARAMS ((tree, int));
 149 static int lookup_flags PARAMS ((int, int));
 150 static tree qualify_lookup PARAMS ((tree, int));
 151 static tree record_builtin_java_type PARAMS ((const char *, int));
 152 static const char *tag_name PARAMS ((enum tag_types code));
 153 static void find_class_binding_level PARAMS ((void));
 154 static struct binding_level *innermost_nonclass_level PARAMS ((void));
 155 static void warn_about_implicit_typename_lookup PARAMS ((tree, tree));
 156 static int walk_namespaces_r PARAMS ((tree, walk_namespaces_fn, void *));
 157 static int walk_globals_r PARAMS ((tree, void *));
 158 static void add_decl_to_level PARAMS ((tree, struct binding_level *));
 159 static tree make_label_decl PARAMS ((tree, int));
 160 static void pop_label PARAMS ((tree));
 161 static void pop_labels PARAMS ((tree));
 162 static void maybe_deduce_size_from_array_init PARAMS ((tree, tree));
 163 static void layout_var_decl PARAMS ((tree));
 164 static void maybe_commonize_var PARAMS ((tree));
 165 static tree check_initializer PARAMS ((tree, tree));
 166 static void make_rtl_for_nonlocal_decl PARAMS ((tree, tree, const char *));
 167 static void push_cp_function_context PARAMS ((struct function *));
 168 static void pop_cp_function_context PARAMS ((struct function *));
 169 static void mark_binding_level PARAMS ((void *));
 170 static void mark_cp_function_context PARAMS ((struct function *));
 171 static void mark_saved_scope PARAMS ((void *));
 172 static void mark_lang_function PARAMS ((struct language_function *));
 173 static void mark_stmt_tree PARAMS ((struct stmt_tree *));
 174 static void save_function_data PARAMS ((tree));
 175 static void check_function_type PARAMS ((tree));
 176 static void destroy_local_var PARAMS ((tree));
 177 static void finish_constructor_body PARAMS ((void));
 178 static void finish_destructor_body PARAMS ((void));
 179 static tree create_array_type_for_decl PARAMS ((tree, tree, tree));
 180 static tree get_atexit_node PARAMS ((void));
 181 static tree get_dso_handle_node PARAMS ((void));
 182 static tree start_cleanup_fn PARAMS ((void));
 183 static void end_cleanup_fn PARAMS ((void));
 184
 185 #if defined (DEBUG_CP_BINDING_LEVELS)
 186 static void indent PARAMS ((void));
 187 #endif
 188
 189 /* Erroneous argument lists can use this *IFF* they do not modify it.  */
 190 tree error_mark_list;
 191
 192 /* The following symbols are subsumed in the cp_global_trees array, and
 193    listed here individually for documentation purposes.
 194
 195    C++ extensions
 196         tree wchar_decl_node;
 197         tree void_zero_node;
 198
 199         tree vtable_entry_type;
 200         tree delta_type_node;
 201 #if 0
 202    Old rtti stuff.
 203         tree __baselist_desc_type_node;
 204         tree __i_desc_type_node, __m_desc_type_node;
 205         tree __t_desc_array_type, __i_desc_array_type, __m_desc_array_type;
 206 #endif
 207         tree __t_desc_type_node;
 208 #if 0
 209         tree __tp_desc_type_node;
 210 #endif
 211         tree ti_desc_type_node;
 212         tree bltn_desc_type_node, ptr_desc_type_node, ref_desc_type_node;
 213         tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
 214         tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
 215         tree ptmd_desc_type_node;
 216         tree base_desc_type_node;
 217 #if 0
 218    Not needed yet?  May be needed one day?
 219         tree __bltn_desc_array_type, __user_desc_array_type, __class_desc_array_type;
 220         tree __ptr_desc_array_type, __attr_dec_array_type, __func_desc_array_type;
 221         tree __ptmf_desc_array_type, __ptmd_desc_array_type;
 222 #endif
 223
 224         tree class_star_type_node;
 225         tree class_type_node, record_type_node, union_type_node, enum_type_node;
 226         tree unknown_type_node;
 227
 228    Array type `vtable_entry_type[]'
 229
 230         tree vtbl_type_node;
 231         tree vtbl_ptr_type_node;
 232
 233    Nnamespace std
 234
 235         tree std_node;
 236
 237    A FUNCTION_DECL which can call `abort'.  Not necessarily the
 238    one that the user will declare, but sufficient to be called
 239    by routines that want to abort the program.
 240
 241         tree abort_fndecl;
 242
 243    The FUNCTION_DECL for the default `::operator delete'.
 244
 245         tree global_delete_fndecl;
 246
 247    Used by RTTI
 248         tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
 249         tree tinfo_var_id;
 250
 251 */
 252
 253 tree cp_global_trees[CPTI_MAX];
 254
 255 /* Indicates that there is a type value in some namespace, although
 256    that is not necessarily in scope at the moment.  */
 257
 258 static tree global_type_node;
 259
 260 /* Namespace std.  */
 261 int in_std;
 262
 263 /* Expect only namespace names now. */
 264 static int only_namespace_names;
 265
 266 /* If original DECL_RESULT of current function was a register,
 267    but due to being an addressable named return value, would up
 268    on the stack, this variable holds the named return value's
 269    original location.  */
 270
 271 #define original_result_rtx cp_function_chain->x_result_rtx
 272
 273 struct named_label_list
 274 {
 275   struct binding_level *binding_level;
 276   tree names_in_scope;
 277   tree label_decl;
 278   const char *filename_o_goto;
 279   int lineno_o_goto;
 280   struct named_label_list *next;
 281 };
 282
 283 /* Used only for jumps to as-yet undefined labels, since jumps to
 284    defined labels can have their validity checked by stmt.c.  */
 285
 286 #define named_label_uses cp_function_chain->x_named_label_uses
 287
 288 /* A list of objects which have constructors or destructors
 289    which reside in the global scope.  The decl is stored in
 290    the TREE_VALUE slot and the initializer is stored
 291    in the TREE_PURPOSE slot.  */
 292 tree static_aggregates;
 293
 294 /* -- end of C++ */
 295
 296 /* A node for the integer constants 2, and 3.  */
 297
 298 tree integer_two_node, integer_three_node;
 299
 300 /* Parsing a function declarator leaves here a chain of structure
 301    and enum types declared in the parmlist.  */
 302
 303 static tree last_function_parm_tags;
 304
 305 /* Similar, for last_function_parm_tags.  */
 306 tree last_function_parms;
 307 static tree current_function_parm_tags;
 308
 309 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
 310    that have names.  Here so we can clear out their names' definitions
 311    at the end of the function.  The TREE_VALUE is a LABEL_DECL; the
 312    TREE_PURPOSE is the previous binding of the label.  */
 313
 314 #define named_labels cp_function_chain->x_named_labels
 315
 316 /* The FUNCTION_DECL for the function currently being compiled,
 317    or 0 if between functions.  */
 318 tree current_function_decl;
 319
 320 /* Set to 0 at beginning of a function definition, and whenever
 321    a label (case or named) is defined.  Set to value of expression
 322    returned from function when that value can be transformed into
 323    a named return value.  */
 324
 325 tree current_function_return_value;
 326
 327 /* Nonzero means use the ISO C99 dialect of C.  */
 328
 329 int flag_isoc99;
 330
 331 /* Nonzero means give `double' the same size as `float'.  */
 332
 333 extern int flag_short_double;
 334
 335 /* Nonzero means don't recognize any builtin functions.  */
 336
 337 extern int flag_no_builtin;
 338
 339 /* Nonzero means don't recognize the non-ANSI builtin functions.
 340    -ansi sets this.  */
 341
 342 extern int flag_no_nonansi_builtin;
 343
 344 /* Nonzero if we want to support huge (> 2^(sizeof(short)*8-1) bytes)
 345    objects.  */
 346 extern int flag_huge_objects;
 347
 348 /* Nonzero if we want to conserve space in the .o files.  We do this
 349    by putting uninitialized data and runtime initialized data into
 350    .common instead of .data at the expense of not flagging multiple
 351    definitions.  */
 352 extern int flag_conserve_space;
 353 \f
 354 /* C and C++ flags are in decl2.c.  */
 355
 356 /* Flag used when debugging spew.c */
 357
 358 extern int spew_debug;
 359
 360 /* A expression of value 0 with the same precision as a sizetype
 361    node, but signed.  */
 362 tree signed_size_zero_node;
 363
 364 /* The name of the anonymous namespace, throughout this translation
 365    unit.  */
 366 tree anonymous_namespace_name;
 367
 368 \f
 369 /* For each binding contour we allocate a binding_level structure
 370    which records the names defined in that contour.
 371    Contours include:
 372     0) the global one
 373     1) one for each function definition,
 374        where internal declarations of the parameters appear.
 375     2) one for each compound statement,
 376        to record its declarations.
 377
 378    The current meaning of a name can be found by searching the levels
 379    from the current one out to the global one.
 380
 381    Off to the side, may be the class_binding_level.  This exists only
 382    to catch class-local declarations.  It is otherwise nonexistent.
 383
 384    Also there may be binding levels that catch cleanups that must be
 385    run when exceptions occur.  Thus, to see whether a name is bound in
 386    the current scope, it is not enough to look in the
 387    CURRENT_BINDING_LEVEL.  You should use lookup_name_current_level
 388    instead.  */
 389
 390 /* Note that the information in the `names' component of the global contour
 391    is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers.  */
 392
 393 struct binding_level
 394   {
 395     /* A chain of _DECL nodes for all variables, constants, functions,
 396        and typedef types.  These are in the reverse of the order
 397        supplied.  There may be OVERLOADs on this list, too, but they
 398        are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD.  */
 399     tree names;
 400
 401     /* A list of structure, union and enum definitions, for looking up
 402        tag names.
 403        It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
 404        or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
 405        or ENUMERAL_TYPE node.
 406
 407        C++: the TREE_VALUE nodes can be simple types for
 408        component_bindings.  */
 409     tree tags;
 410
 411     /* A list of USING_DECL nodes. */
 412     tree usings;
 413
 414     /* A list of used namespaces. PURPOSE is the namespace,
 415        VALUE the common ancestor with this binding_level's namespace. */
 416     tree using_directives;
 417
 418     /* If this binding level is the binding level for a class, then
 419        class_shadowed is a TREE_LIST.  The TREE_PURPOSE of each node
 420        is the name of an entity bound in the class; the TREE_VALUE is
 421        the IDENTIFIER_CLASS_VALUE before we entered the class.  Thus,
 422        when leaving class scope, we can restore the
 423        IDENTIFIER_CLASS_VALUE by walking this list.  The TREE_TYPE is
 424        the DECL bound by this name in the class.  */
 425     tree class_shadowed;
 426
 427     /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
 428        is used for all binding levels.  */
 429     tree type_shadowed;
 430
 431     /* A TREE_LIST.  Each TREE_VALUE is the LABEL_DECL for a local
 432        label in this scope.  The TREE_PURPOSE is the previous value of
 433        the IDENTIFIER_LABEL VALUE.  */
 434     tree shadowed_labels;
 435
 436     /* For each level (except not the global one),
 437        a chain of BLOCK nodes for all the levels
 438        that were entered and exited one level down.  */
 439     tree blocks;
 440
 441     /* The BLOCK node for this level, if one has been preallocated.
 442        If 0, the BLOCK is allocated (if needed) when the level is popped.  */
 443     tree this_block;
 444
 445     /* The _TYPE node for this level, if parm_flag == 2.  */
 446     tree this_class;
 447
 448     /* The binding level which this one is contained in (inherits from).  */
 449     struct binding_level *level_chain;
 450
 451     /* List of decls in `names' that have incomplete
 452        structure or union types.  */
 453     tree incomplete;
 454
 455     /* List of VAR_DECLS saved from a previous for statement.
 456        These would be dead in ANSI-conforming code, but might
 457        be referenced in ARM-era code.  These are stored in a
 458        TREE_LIST; the TREE_VALUE is the actual declaration.  */
 459     tree dead_vars_from_for;
 460
 461     /* 1 for the level that holds the parameters of a function.
 462        2 for the level that holds a class declaration.
 463        3 for levels that hold parameter declarations.  */
 464     unsigned parm_flag : 4;
 465
 466     /* 1 means make a BLOCK for this level regardless of all else.
 467        2 for temporary binding contours created by the compiler.  */
 468     unsigned keep : 3;
 469
 470     /* Nonzero if this level "doesn't exist" for tags.  */
 471     unsigned tag_transparent : 1;
 472
 473     /* Nonzero if this level can safely have additional
 474        cleanup-needing variables added to it.  */
 475     unsigned more_cleanups_ok : 1;
 476     unsigned have_cleanups : 1;
 477
 478     /* Nonzero if this level is for storing the decls for template
 479        parameters and generic decls; these decls will be discarded and
 480        replaced with a TEMPLATE_DECL.  */
 481     unsigned pseudo_global : 1;
 482
 483     /* This is set for a namespace binding level.  */
 484     unsigned namespace_p : 1;
 485
 486     /* True if this level is that of a for-statement where we need to
 487        worry about ambiguous (ARM or ANSI) scope rules.  */
 488     unsigned is_for_scope : 1;
 489
 490     /* True if this level corresponds to an EH region, as for a try block.  */
 491     unsigned eh_region : 1;
 492
 493     /* One bit left for this word.  */
 494
 495 #if defined(DEBUG_CP_BINDING_LEVELS)
 496     /* Binding depth at which this level began.  */
 497     unsigned binding_depth;
 498 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 499   };
 500
 501 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
 502
 503 /* The binding level currently in effect.  */
 504
 505 #define current_binding_level                   \
 506   (cfun                                         \
 507    ? cp_function_chain->bindings                \
 508    : scope_chain->bindings)
 509
 510 /* The binding level of the current class, if any.  */
 511
 512 #define class_binding_level scope_chain->class_bindings
 513
 514 /* A chain of binding_level structures awaiting reuse.  */
 515
 516 static struct binding_level *free_binding_level;
 517
 518 /* The outermost binding level, for names of file scope.
 519    This is created when the compiler is started and exists
 520    through the entire run.  */
 521
 522 static struct binding_level *global_binding_level;
 523
 524 /* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
 525
 526 static int keep_next_level_flag;
 527
 528 #if defined(DEBUG_CP_BINDING_LEVELS)
 529 static int binding_depth = 0;
 530 static int is_class_level = 0;
 531
 532 static void
 533 indent ()
 534 {
 535   register unsigned i;
 536
 537   for (i = 0; i < binding_depth*2; i++)
 538     putc (' ', stderr);
 539 }
 540 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 541
 542 static tree pushdecl_with_scope PARAMS ((tree, struct binding_level *));
 543
 544 static void
 545 push_binding_level (newlevel, tag_transparent, keep)
 546      struct binding_level *newlevel;
 547      int tag_transparent, keep;
 548 {
 549   /* Add this level to the front of the chain (stack) of levels that
 550      are active.  */
 551   bzero ((char*) newlevel, sizeof (struct binding_level));
 552   newlevel->level_chain = current_binding_level;
 553   current_binding_level = newlevel;
 554   newlevel->tag_transparent = tag_transparent;
 555   newlevel->more_cleanups_ok = 1;
 556
 557   /* We are called before expand_start_bindings, but after
 558      expand_eh_region_start for a try block; so we check this now,
 559      before the EH block is covered up.  */
 560   newlevel->eh_region = is_eh_region ();
 561
 562   newlevel->keep = keep;
 563 #if defined(DEBUG_CP_BINDING_LEVELS)
 564   newlevel->binding_depth = binding_depth;
 565   indent ();
 566   fprintf (stderr, "push %s level 0x%08x line %d\n",
 567            (is_class_level) ? "class" : "block", newlevel, lineno);
 568   is_class_level = 0;
 569   binding_depth++;
 570 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 571 }
 572
 573 /* Find the innermost enclosing class scope, and reset
 574    CLASS_BINDING_LEVEL appropriately.  */
 575
 576 static void
 577 find_class_binding_level ()
 578 {
 579   struct binding_level *level = current_binding_level;
 580
 581   while (level && level->parm_flag != 2)
 582     level = level->level_chain;
 583   if (level && level->parm_flag == 2)
 584     class_binding_level = level;
 585   else
 586     class_binding_level = 0;
 587 }
 588
 589 static void
 590 pop_binding_level ()
 591 {
 592   if (global_binding_level)
 593     {
 594       /* Cannot pop a level, if there are none left to pop.  */
 595       if (current_binding_level == global_binding_level)
 596         my_friendly_abort (123);
 597     }
 598   /* Pop the current level, and free the structure for reuse.  */
 599 #if defined(DEBUG_CP_BINDING_LEVELS)
 600   binding_depth--;
 601   indent ();
 602   fprintf (stderr, "pop  %s level 0x%08x line %d\n",
 603           (is_class_level) ? "class" : "block",
 604           current_binding_level, lineno);
 605   if (is_class_level != (current_binding_level == class_binding_level))
 606     {
 607       indent ();
 608       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 609     }
 610   is_class_level = 0;
 611 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 612   {
 613     register struct binding_level *level = current_binding_level;
 614     current_binding_level = current_binding_level->level_chain;
 615     level->level_chain = free_binding_level;
 616 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
 617     if (level->binding_depth != binding_depth)
 618       abort ();
 619 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 620     free_binding_level = level;
 621     find_class_binding_level ();
 622   }
 623 }
 624
 625 static void
 626 suspend_binding_level ()
 627 {
 628   if (class_binding_level)
 629     current_binding_level = class_binding_level;
 630
 631   if (global_binding_level)
 632     {
 633       /* Cannot suspend a level, if there are none left to suspend.  */
 634       if (current_binding_level == global_binding_level)
 635         my_friendly_abort (123);
 636     }
 637   /* Suspend the current level.  */
 638 #if defined(DEBUG_CP_BINDING_LEVELS)
 639   binding_depth--;
 640   indent ();
 641   fprintf (stderr, "suspend  %s level 0x%08x line %d\n",
 642           (is_class_level) ? "class" : "block",
 643           current_binding_level, lineno);
 644   if (is_class_level != (current_binding_level == class_binding_level))
 645     {
 646       indent ();
 647       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 648     }
 649   is_class_level = 0;
 650 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 651   current_binding_level = current_binding_level->level_chain;
 652   find_class_binding_level ();
 653 }
 654
 655 static void
 656 resume_binding_level (b)
 657      struct binding_level *b;
 658 {
 659   /* Resuming binding levels is meant only for namespaces,
 660      and those cannot nest into classes. */
 661   my_friendly_assert(!class_binding_level, 386);
 662   /* Also, resuming a non-directly nested namespace is a no-no.  */
 663   my_friendly_assert(b->level_chain == current_binding_level, 386);
 664   current_binding_level = b;
 665 #if defined(DEBUG_CP_BINDING_LEVELS)
 666   b->binding_depth = binding_depth;
 667   indent ();
 668   fprintf (stderr, "resume %s level 0x%08x line %d\n",
 669            (is_class_level) ? "class" : "block", b, lineno);
 670   is_class_level = 0;
 671   binding_depth++;
 672 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 673 }
 674 \f
 675 /* Create a new `struct binding_level'.  */
 676
 677 static
 678 struct binding_level *
 679 make_binding_level ()
 680 {
 681   /* NOSTRICT */
 682   return (struct binding_level *) xmalloc (sizeof (struct binding_level));
 683 }
 684
 685 /* Nonzero if we are currently in the global binding level.  */
 686
 687 int
 688 global_bindings_p ()
 689 {
 690   return current_binding_level == global_binding_level;
 691 }
 692
 693 /* Return the innermost binding level that is not for a class scope.  */
 694
 695 static struct binding_level *
 696 innermost_nonclass_level ()
 697 {
 698   struct binding_level *b;
 699
 700   b = current_binding_level;
 701   while (b->parm_flag == 2)
 702     b = b->level_chain;
 703
 704   return b;
 705 }
 706
 707 /* Nonzero if we are currently in a toplevel binding level.  This
 708    means either the global binding level or a namespace in a toplevel
 709    binding level.  Since there are no non-toplevel namespace levels,
 710    this really means any namespace or pseudo-global level.  We also
 711    include a class whose context is toplevel.  */
 712
 713 int
 714 toplevel_bindings_p ()
 715 {
 716   struct binding_level *b = innermost_nonclass_level ();
 717
 718   return b->namespace_p || b->pseudo_global;
 719 }
 720
 721 /* Nonzero if this is a namespace scope, or if we are defining a class
 722    which is itself at namespace scope, or whose enclosing class is
 723    such a class, etc.  */
 724
 725 int
 726 namespace_bindings_p ()
 727 {
 728   struct binding_level *b = innermost_nonclass_level ();
 729
 730   return b->namespace_p;
 731 }
 732
 733 /* If KEEP is non-zero, make a BLOCK node for the next binding level,
 734    unconditionally.  Otherwise, use the normal logic to decide whether
 735    or not to create a BLOCK.  */
 736
 737 void
 738 keep_next_level (keep)
 739      int keep;
 740 {
 741   keep_next_level_flag = keep;
 742 }
 743
 744 /* Nonzero if the current level needs to have a BLOCK made.  */
 745
 746 int
 747 kept_level_p ()
 748 {
 749   return (current_binding_level->blocks != NULL_TREE
 750           || current_binding_level->keep
 751           || current_binding_level->names != NULL_TREE
 752           || (current_binding_level->tags != NULL_TREE
 753               && !current_binding_level->tag_transparent));
 754 }
 755
 756 void
 757 declare_pseudo_global_level ()
 758 {
 759   current_binding_level->pseudo_global = 1;
 760 }
 761
 762 static void
 763 declare_namespace_level ()
 764 {
 765   current_binding_level->namespace_p = 1;
 766 }
 767
 768 int
 769 pseudo_global_level_p ()
 770 {
 771   return current_binding_level->pseudo_global;
 772 }
 773
 774 void
 775 set_class_shadows (shadows)
 776      tree shadows;
 777 {
 778   class_binding_level->class_shadowed = shadows;
 779 }
 780
 781 /* Enter a new binding level.
 782    If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
 783    not for that of tags.  */
 784
 785 void
 786 pushlevel (tag_transparent)
 787      int tag_transparent;
 788 {
 789   struct binding_level *newlevel;
 790
 791   if (cfun && !doing_semantic_analysis_p ())
 792     return;
 793
 794   /* Reuse or create a struct for this binding level.  */
 795 #if defined(DEBUG_CP_BINDING_LEVELS)
 796   if (0)
 797 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
 798   if (free_binding_level)
 799 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
 800     {
 801       newlevel = free_binding_level;
 802       free_binding_level = free_binding_level->level_chain;
 803     }
 804   else
 805     newlevel = make_binding_level ();
 806
 807   push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
 808   GNU_xref_start_scope ((HOST_WIDE_INT) newlevel);
 809   keep_next_level_flag = 0;
 810 }
 811
 812 void
 813 note_level_for_for ()
 814 {
 815   current_binding_level->is_for_scope = 1;
 816 }
 817
 818 /* For a binding between a name and an entity at a block scope,
 819    this is the `struct binding_level' for the block.  */
 820 #define BINDING_LEVEL(NODE) \
 821    (((struct tree_binding*)NODE)->scope.level)
 822
 823 /* Make DECL the innermost binding for ID.  The LEVEL is the binding
 824    level at which this declaration is being bound.  */
 825
 826 static void
 827 push_binding (id, decl, level)
 828      tree id;
 829      tree decl;
 830      struct binding_level* level;
 831 {
 832   tree binding;
 833
 834   binding = make_node (CPLUS_BINDING);
 835
 836   /* Now, fill in the binding information.  */
 837   BINDING_VALUE (binding) = decl;
 838   BINDING_TYPE (binding) = NULL_TREE;
 839   BINDING_LEVEL (binding) = level;
 840   INHERITED_VALUE_BINDING_P (binding) = 0;
 841   LOCAL_BINDING_P (binding) = (level != class_binding_level);
 842   BINDING_HAS_LEVEL_P (binding) = 1;
 843
 844   /* And put it on the front of the list of bindings for ID.  */
 845   TREE_CHAIN (binding) = IDENTIFIER_BINDING (id);
 846   IDENTIFIER_BINDING (id) = binding;
 847 }
 848
 849 /* ID is already bound in the current scope.  But, DECL is an
 850    additional binding for ID in the same scope.  This is the `struct
 851    stat' hack whereby a non-typedef class-name or enum-name can be
 852    bound at the same level as some other kind of entity.  It's the
 853    responsibility of the caller to check that inserting this name is
 854    legal here.  Returns nonzero if the new binding was successful.  */
 855 static int
 856 add_binding (id, decl)
 857      tree id;
 858      tree decl;
 859 {
 860   tree binding = IDENTIFIER_BINDING (id);
 861   int ok = 1;
 862
 863   if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
 864     /* The new name is the type name.  */
 865     BINDING_TYPE (binding) = decl;
 866   else if (!BINDING_VALUE (binding))
 867     /* This situation arises when push_class_level_binding moves an
 868        inherited type-binding out of the way to make room for a new
 869        value binding.  */
 870     BINDING_VALUE (binding) = decl;
 871   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
 872            && DECL_ARTIFICIAL (BINDING_VALUE (binding)))
 873     {
 874       /* The old binding was a type name.  It was placed in
 875          BINDING_VALUE because it was thought, at the point it was
 876          declared, to be the only entity with such a name.  Move the
 877          type name into the type slot; it is now hidden by the new
 878          binding.  */
 879       BINDING_TYPE (binding) = BINDING_VALUE (binding);
 880       BINDING_VALUE (binding) = decl;
 881       INHERITED_VALUE_BINDING_P (binding) = 0;
 882     }
 883   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
 884            && TREE_CODE (decl) == TYPE_DECL
 885            && DECL_NAME (decl) == DECL_NAME (BINDING_VALUE (binding))
 886            && same_type_p (TREE_TYPE (decl),
 887                            TREE_TYPE (BINDING_VALUE (binding))))
 888     /* We have two typedef-names, both naming the same type to have
 889        the same name.  This is OK because of:
 890
 891          [dcl.typedef]
 892
 893          In a given scope, a typedef specifier can be used to redefine
 894          the name of any type declared in that scope to refer to the
 895          type to which it already refers.  */
 896     ok = 0;
 897   else
 898     {
 899       cp_error ("declaration of `%#D'", decl);
 900       cp_error_at ("conflicts with previous declaration `%#D'",
 901                    BINDING_VALUE (binding));
 902       ok = 0;
 903     }
 904
 905   return ok;
 906 }
 907
 908 /* Add DECL to the list of things declared in B.  */
 909
 910 static void
 911 add_decl_to_level (decl, b)
 912      tree decl;
 913      struct binding_level *b;
 914 {
 915   /* We build up the list in reverse order, and reverse it later if
 916      necessary.  */
 917   TREE_CHAIN (decl) = b->names;
 918   b->names = decl;
 919 }
 920
 921 /* Bind DECL to ID in the current_binding_level, assumed to be a local
 922    binding level.  If PUSH_USING is set in FLAGS, we know that DECL
 923    doesn't really belong to this binding level, that it got here
 924    through a using-declaration.  */
 925
 926 void
 927 push_local_binding (id, decl, flags)
 928      tree id;
 929      tree decl;
 930      int flags;
 931 {
 932   struct binding_level *b;
 933
 934   /* Skip over any local classes.  This makes sense if we call
 935      push_local_binding with a friend decl of a local class.  */
 936   b = current_binding_level;
 937   while (b->parm_flag == 2)
 938     b = b->level_chain;
 939
 940   if (lookup_name_current_level (id))
 941     {
 942       /* Supplement the existing binding.  */
 943       if (!add_binding (id, decl))
 944         /* It didn't work.  Something else must be bound at this
 945            level.  Do not add DECL to the list of things to pop
 946            later.  */
 947         return;
 948     }
 949   else
 950     /* Create a new binding.  */
 951     push_binding (id, decl, b);
 952
 953   if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
 954     /* We must put the OVERLOAD into a TREE_LIST since the
 955        TREE_CHAIN of an OVERLOAD is already used.  Similarly for
 956        decls that got here through a using-declaration.  */
 957     decl = build_tree_list (NULL_TREE, decl);
 958
 959   /* And put DECL on the list of things declared by the current
 960      binding level.  */
 961   add_decl_to_level (decl, b);
 962 }
 963
 964 /* Bind DECL to ID in the class_binding_level.  Returns nonzero if the
 965    binding was successful.  */
 966
 967 int
 968 push_class_binding (id, decl)
 969      tree id;
 970      tree decl;
 971 {
 972   int result = 1;
 973   tree binding = IDENTIFIER_BINDING (id);
 974   tree context;
 975
 976   /* Note that we declared this value so that we can issue an error if
 977      this an illegal redeclaration of a name already used for some
 978      other purpose.  */
 979   note_name_declared_in_class (id, decl);
 980
 981   if (binding && BINDING_LEVEL (binding) == class_binding_level)
 982     /* Supplement the existing binding.  */
 983     result = add_binding (id, decl);
 984   else
 985     /* Create a new binding.  */
 986     push_binding (id, decl, class_binding_level);
 987
 988   /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
 989      class-level declaration.  Note that we do not use DECL here
 990      because of the possibility of the `struct stat' hack; if DECL is
 991      a class-name or enum-name we might prefer a field-name, or some
 992      such.  */
 993   IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
 994
 995   /* If this is a binding from a base class, mark it as such.  */
 996   binding = IDENTIFIER_BINDING (id);
 997   if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
 998     {
 999       /* Any implicit typename must be from a base-class.  The
1000          context for an implicit typename declaration is always
1001          the derived class in which the lookup was done, so the checks
1002          based on the context of DECL below will not trigger.  */
1003       if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl))
1004         INHERITED_VALUE_BINDING_P (binding) = 1;
1005       else
1006         {
1007           if (TREE_CODE (decl) == OVERLOAD)
1008             context = DECL_REAL_CONTEXT (OVL_CURRENT (decl));
1009           else
1010             {
1011               my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (decl)) == 'd',
1012                                   0);
1013               context = DECL_REAL_CONTEXT (decl);
1014             }
1015
1016           if (is_properly_derived_from (current_class_type, context))
1017             INHERITED_VALUE_BINDING_P (binding) = 1;
1018           else
1019             INHERITED_VALUE_BINDING_P (binding) = 0;
1020         }
1021     }
1022   else if (BINDING_VALUE (binding) == decl)
1023     /* We only encounter a TREE_LIST when push_class_decls detects an
1024        ambiguity.  Such an ambiguity can be overridden by a definition
1025        in this class.  */
1026     INHERITED_VALUE_BINDING_P (binding) = 1;
1027
1028   return result;
1029 }
1030
1031 /* Remove the binding for DECL which should be the innermost binding
1032    for ID.  */
1033
1034 static void
1035 pop_binding (id, decl)
1036      tree id;
1037      tree decl;
1038 {
1039   tree binding;
1040
1041   if (id == NULL_TREE)
1042     /* It's easiest to write the loops that call this function without
1043        checking whether or not the entities involved have names.  We
1044        get here for such an entity.  */
1045     return;
1046
1047   /* Get the innermost binding for ID.  */
1048   binding = IDENTIFIER_BINDING (id);
1049
1050   /* The name should be bound.  */
1051   my_friendly_assert (binding != NULL_TREE, 0);
1052
1053   /* The DECL will be either the ordinary binding or the type
1054      binding for this identifier.  Remove that binding.  */
1055   if (BINDING_VALUE (binding) == decl)
1056     BINDING_VALUE (binding) = NULL_TREE;
1057   else if (BINDING_TYPE (binding) == decl)
1058     BINDING_TYPE (binding) = NULL_TREE;
1059   else
1060     my_friendly_abort (0);
1061
1062   if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
1063     /* We're completely done with the innermost binding for this
1064        identifier.  Unhook it from the list of bindings.  */
1065     IDENTIFIER_BINDING (id) = TREE_CHAIN (binding);
1066 }
1067
1068 /* When a label goes out of scope, check to see if that label was used
1069    in a valid manner, and issue any appropriate warnings or errors.  */
1070
1071 static void
1072 pop_label (link)
1073      tree link;
1074 {
1075   tree label = TREE_VALUE (link);
1076
1077   if (!processing_template_decl && doing_semantic_analysis_p ())
1078     {
1079       if (DECL_INITIAL (label) == NULL_TREE)
1080         {
1081           cp_error_at ("label `%D' used but not defined", label);
1082           /* Avoid crashing later.  */
1083           define_label (input_filename, 1, DECL_NAME (label));
1084         }
1085       else if (warn_unused && !TREE_USED (label))
1086         cp_warning_at ("label `%D' defined but not used", label);
1087     }
1088
1089   SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), TREE_PURPOSE (link));
1090 }
1091
1092 /* At the end of a function, all labels declared within the fucntion
1093    go out of scope.  BLOCK is the top-level block for the
1094    function.  */
1095
1096 static void
1097 pop_labels (block)
1098      tree block;
1099 {
1100   tree link;
1101
1102   /* Clear out the definitions of all label names, since their scopes
1103      end here.  */
1104   for (link = named_labels; link; link = TREE_CHAIN (link))
1105     {
1106       pop_label (link);
1107       /* Put the labels into the "variables" of the top-level block,
1108          so debugger can see them.  */
1109       TREE_CHAIN (TREE_VALUE (link)) = BLOCK_VARS (block);
1110       BLOCK_VARS (block) = TREE_VALUE (link);
1111     }
1112
1113   named_labels = NULL_TREE;
1114 }
1115
1116 /* Exit a binding level.
1117    Pop the level off, and restore the state of the identifier-decl mappings
1118    that were in effect when this level was entered.
1119
1120    If KEEP == 1, this level had explicit declarations, so
1121    and create a "block" (a BLOCK node) for the level
1122    to record its declarations and subblocks for symbol table output.
1123
1124    If FUNCTIONBODY is nonzero, this level is the body of a function,
1125    so create a block as if KEEP were set and also clear out all
1126    label names.
1127
1128    If REVERSE is nonzero, reverse the order of decls before putting
1129    them into the BLOCK.  */
1130
1131 tree
1132 poplevel (keep, reverse, functionbody)
1133      int keep;
1134      int reverse;
1135      int functionbody;
1136 {
1137   register tree link;
1138   /* The chain of decls was accumulated in reverse order.
1139      Put it into forward order, just for cleanliness.  */
1140   tree decls;
1141   int tmp = functionbody;
1142   int real_functionbody;
1143   tree tags;
1144   tree subblocks;
1145   tree block = NULL_TREE;
1146   tree decl;
1147   int block_previously_created;
1148   int leaving_for_scope;
1149
1150   if (cfun && !doing_semantic_analysis_p ())
1151     return NULL_TREE;
1152
1153   my_friendly_assert (current_binding_level->parm_flag != 2,
1154                       19990916);
1155
1156   real_functionbody = (current_binding_level->keep == 2
1157                        ? ((functionbody = 0), tmp) : functionbody);
1158   tags = functionbody >= 0 ? current_binding_level->tags : 0;
1159   subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1160
1161   my_friendly_assert (!current_binding_level->class_shadowed,
1162                       19990414);
1163
1164   /* We used to use KEEP == 2 to indicate that the new block should go
1165      at the beginning of the list of blocks at this binding level,
1166      rather than the end.  This hack is no longer used.  */
1167   my_friendly_assert (keep == 0 || keep == 1, 0);
1168
1169   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
1170                       (HOST_WIDE_INT) current_binding_level->level_chain,
1171                       current_binding_level->parm_flag,
1172                       current_binding_level->keep);
1173
1174   if (current_binding_level->keep == 1)
1175     keep = 1;
1176
1177   /* Get the decls in the order they were written.
1178      Usually current_binding_level->names is in reverse order.
1179      But parameter decls were previously put in forward order.  */
1180
1181   if (reverse)
1182     current_binding_level->names
1183       = decls = nreverse (current_binding_level->names);
1184   else
1185     decls = current_binding_level->names;
1186
1187   /* Output any nested inline functions within this block
1188      if they weren't already output.  */
1189   for (decl = decls; decl; decl = TREE_CHAIN (decl))
1190     if (TREE_CODE (decl) == FUNCTION_DECL
1191         && ! TREE_ASM_WRITTEN (decl)
1192         && DECL_INITIAL (decl) != NULL_TREE
1193         && TREE_ADDRESSABLE (decl)
1194         && decl_function_context (decl) == current_function_decl)
1195       {
1196         /* If this decl was copied from a file-scope decl
1197            on account of a block-scope extern decl,
1198            propagate TREE_ADDRESSABLE to the file-scope decl.  */
1199         if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1200           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1201         else
1202           {
1203             push_function_context ();
1204             output_inline_function (decl);
1205             pop_function_context ();
1206           }
1207       }
1208
1209   /* When not in function-at-a-time mode, expand_end_bindings will
1210      warn about unused variables.  But, in function-at-a-time mode
1211      expand_end_bindings is not passed the list of variables in the
1212      current scope, and therefore no warning is emitted.  So, we
1213      explicitly warn here.  */
1214   if (!processing_template_decl)
1215     warn_about_unused_variables (getdecls ());
1216
1217   /* If there were any declarations or structure tags in that level,
1218      or if this level is a function body,
1219      create a BLOCK to record them for the life of this function.  */
1220   block = NULL_TREE;
1221   block_previously_created = (current_binding_level->this_block != NULL_TREE);
1222   if (block_previously_created)
1223     block = current_binding_level->this_block;
1224   else if (keep == 1 || functionbody)
1225     block = make_node (BLOCK);
1226   if (block != NULL_TREE)
1227     {
1228       if (block_previously_created)
1229         {
1230           if (decls || tags || subblocks)
1231             {
1232               if (BLOCK_VARS (block))
1233                 warning ("internal compiler error: debugging info corrupted");
1234
1235               BLOCK_VARS (block) = decls;
1236
1237               /* We can have previous subblocks and new subblocks when
1238                  doing fixup_gotos with complex cleanups.  We chain the new
1239                  subblocks onto the end of any pre-existing subblocks.  */
1240               BLOCK_SUBBLOCKS (block) = chainon (BLOCK_SUBBLOCKS (block),
1241                                                  subblocks);
1242             }
1243         }
1244       else
1245         {
1246           BLOCK_VARS (block) = decls;
1247           BLOCK_SUBBLOCKS (block) = subblocks;
1248         }
1249     }
1250
1251   /* In each subblock, record that this is its superior.  */
1252   if (keep >= 0)
1253     for (link = subblocks; link; link = TREE_CHAIN (link))
1254       BLOCK_SUPERCONTEXT (link) = block;
1255
1256   /* We still support the old for-scope rules, whereby the variables
1257      in a for-init statement were in scope after the for-statement
1258      ended.  We only use the new rules in flag_new_for_scope is
1259      nonzero.  */
1260   leaving_for_scope
1261     = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1262
1263   /* Remove declarations for all the DECLs in this level.  */
1264   for (link = decls; link; link = TREE_CHAIN (link))
1265     {
1266       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL)
1267         {
1268           tree outer_binding
1269             = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1270           tree ns_binding;
1271
1272           if (!outer_binding)
1273             ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1274           else
1275             ns_binding = NULL_TREE;
1276
1277           if (outer_binding
1278               && (BINDING_LEVEL (outer_binding)
1279                   == current_binding_level->level_chain))
1280             /* We have something like:
1281
1282                  int i;
1283                  for (int i; ;);
1284
1285                and we are leaving the `for' scope.  There's no reason to
1286                keep the binding of the inner `i' in this case.  */
1287             pop_binding (DECL_NAME (link), link);
1288           else if ((outer_binding
1289                     && (TREE_CODE (BINDING_VALUE (outer_binding))
1290                         == TYPE_DECL))
1291                    || (ns_binding
1292                        && TREE_CODE (ns_binding) == TYPE_DECL))
1293             /* Here, we have something like:
1294
1295                  typedef int I;
1296
1297                  void f () {
1298                    for (int I; ;);
1299                  }
1300
1301                We must pop the for-scope binding so we know what's a
1302                type and what isn't.  */
1303             pop_binding (DECL_NAME (link), link);
1304           else
1305             {
1306               /* Mark this VAR_DECL as dead so that we can tell we left it
1307                  there only for backward compatibility.  */
1308               DECL_DEAD_FOR_LOCAL (link) = 1;
1309
1310               /* Keep track of what should of have happenned when we
1311                  popped the binding.  */
1312               if (outer_binding && BINDING_VALUE (outer_binding))
1313                 DECL_SHADOWED_FOR_VAR (link)
1314                   = BINDING_VALUE (outer_binding);
1315
1316               /* Add it to the list of dead variables in the next
1317                  outermost binding to that we can remove these when we
1318                  leave that binding.  */
1319               current_binding_level->level_chain->dead_vars_from_for
1320                 = tree_cons (NULL_TREE, link,
1321                              current_binding_level->level_chain->
1322                              dead_vars_from_for);
1323
1324               /* Although we don't pop the CPLUS_BINDING, we do clear
1325                  its BINDING_LEVEL since the level is going away now.  */
1326               BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1327                 = 0;
1328             }
1329         }
1330       else
1331         {
1332           /* Remove the binding.  */
1333           decl = link;
1334           if (TREE_CODE (decl) == TREE_LIST)
1335             decl = TREE_VALUE (decl);
1336           if (TREE_CODE_CLASS (TREE_CODE (decl)) == 'd')
1337             pop_binding (DECL_NAME (decl), decl);
1338           else if (TREE_CODE (decl) == OVERLOAD)
1339             pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1340           else
1341             my_friendly_abort (0);
1342         }
1343     }
1344
1345   /* Remove declarations for any `for' variables from inner scopes
1346      that we kept around.  */
1347   for (link = current_binding_level->dead_vars_from_for;
1348        link; link = TREE_CHAIN (link))
1349     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1350
1351   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
1352   for (link = current_binding_level->type_shadowed;
1353        link; link = TREE_CHAIN (link))
1354     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1355
1356   /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
1357   for (link = current_binding_level->shadowed_labels;
1358        link;
1359        link = TREE_CHAIN (link))
1360     pop_label (link);
1361
1362   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1363      list if a `using' declaration put them there.  The debugging
1364      back-ends won't understand OVERLOAD, so we remove them here.
1365      Because the BLOCK_VARS are (temporarily) shared with
1366      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1367      popped all the bindings.  */
1368   if (block)
1369     {
1370       tree* d;
1371
1372       for (d = &BLOCK_VARS (block); *d; )
1373         {
1374           if (TREE_CODE (*d) == TREE_LIST)
1375             *d = TREE_CHAIN (*d);
1376           else
1377             d = &TREE_CHAIN (*d);
1378         }
1379     }
1380
1381   /* If the level being exited is the top level of a function,
1382      check over all the labels.  */
1383   if (functionbody)
1384     {
1385       /* Since this is the top level block of a function, the vars are
1386          the function's parameters.  Don't leave them in the BLOCK
1387          because they are found in the FUNCTION_DECL instead.  */
1388       BLOCK_VARS (block) = 0;
1389       pop_labels (block);
1390     }
1391
1392   /* Any uses of undefined labels now operate under constraints
1393      of next binding contour.  */
1394   if (cfun)
1395     {
1396       struct binding_level *level_chain;
1397       level_chain = current_binding_level->level_chain;
1398       if (level_chain)
1399         {
1400           struct named_label_list *labels;
1401           for (labels = named_label_uses; labels; labels = labels->next)
1402             if (labels->binding_level == current_binding_level)
1403               {
1404                 labels->binding_level = level_chain;
1405                 labels->names_in_scope = level_chain->names;
1406               }
1407         }
1408     }
1409
1410   tmp = current_binding_level->keep;
1411
1412   pop_binding_level ();
1413   if (functionbody)
1414     DECL_INITIAL (current_function_decl) = block;
1415   else if (block)
1416     {
1417       if (!block_previously_created)
1418         current_binding_level->blocks
1419           = chainon (current_binding_level->blocks, block);
1420     }
1421   /* If we did not make a block for the level just exited,
1422      any blocks made for inner levels
1423      (since they cannot be recorded as subblocks in that level)
1424      must be carried forward so they will later become subblocks
1425      of something else.  */
1426   else if (subblocks)
1427     current_binding_level->blocks
1428       = chainon (current_binding_level->blocks, subblocks);
1429
1430   /* Each and every BLOCK node created here in `poplevel' is important
1431      (e.g. for proper debugging information) so if we created one
1432      earlier, mark it as "used".  */
1433   if (block)
1434     TREE_USED (block) = 1;
1435
1436   /* Take care of compiler's internal binding structures.  */
1437   if (tmp == 2)
1438     {
1439       tree scope_stmts;
1440
1441       scope_stmts
1442         = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1443       if (block)
1444         {
1445           SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1446           SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1447         }
1448
1449       block = poplevel (keep, reverse, functionbody);
1450     }
1451
1452   return block;
1453 }
1454
1455 /* Delete the node BLOCK from the current binding level.
1456    This is used for the block inside a stmt expr ({...})
1457    so that the block can be reinserted where appropriate.  */
1458
1459 void
1460 delete_block (block)
1461      tree block;
1462 {
1463   tree t;
1464   if (current_binding_level->blocks == block)
1465     current_binding_level->blocks = TREE_CHAIN (block);
1466   for (t = current_binding_level->blocks; t;)
1467     {
1468       if (TREE_CHAIN (t) == block)
1469         TREE_CHAIN (t) = TREE_CHAIN (block);
1470       else
1471         t = TREE_CHAIN (t);
1472     }
1473   TREE_CHAIN (block) = NULL_TREE;
1474   /* Clear TREE_USED which is always set by poplevel.
1475      The flag is set again if insert_block is called.  */
1476   TREE_USED (block) = 0;
1477 }
1478
1479 /* Insert BLOCK at the end of the list of subblocks of the
1480    current binding level.  This is used when a BIND_EXPR is expanded,
1481    to handle the BLOCK node inside the BIND_EXPR.  */
1482
1483 void
1484 insert_block (block)
1485      tree block;
1486 {
1487   TREE_USED (block) = 1;
1488   current_binding_level->blocks
1489     = chainon (current_binding_level->blocks, block);
1490 }
1491
1492 /* Set the BLOCK node for the innermost scope
1493    (the one we are currently in).  */
1494
1495 void
1496 set_block (block)
1497     register tree block;
1498 {
1499   current_binding_level->this_block = block;
1500 }
1501
1502 /* Do a pushlevel for class declarations.  */
1503
1504 void
1505 pushlevel_class ()
1506 {
1507   register struct binding_level *newlevel;
1508
1509   /* Reuse or create a struct for this binding level.  */
1510 #if defined(DEBUG_CP_BINDING_LEVELS)
1511   if (0)
1512 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1513   if (free_binding_level)
1514 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1515     {
1516       newlevel = free_binding_level;
1517       free_binding_level = free_binding_level->level_chain;
1518     }
1519   else
1520     newlevel = make_binding_level ();
1521
1522 #if defined(DEBUG_CP_BINDING_LEVELS)
1523   is_class_level = 1;
1524 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1525
1526   push_binding_level (newlevel, 0, 0);
1527
1528   class_binding_level = current_binding_level;
1529   class_binding_level->parm_flag = 2;
1530   class_binding_level->this_class = current_class_type;
1531 }
1532
1533 /* ...and a poplevel for class declarations.  */
1534
1535 void
1536 poplevel_class ()
1537 {
1538   register struct binding_level *level = class_binding_level;
1539   tree shadowed;
1540
1541   my_friendly_assert (level != 0, 354);
1542
1543   /* If we're leaving a toplevel class, don't bother to do the setting
1544      of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1545      shouldn't even be used when current_class_type isn't set, and second,
1546      if we don't touch it here, we're able to use the cache effect if the
1547      next time we're entering a class scope, it is the same class.  */
1548   if (current_class_depth != 1)
1549     {
1550       struct binding_level* b;
1551
1552       /* Clear out our IDENTIFIER_CLASS_VALUEs.  */
1553       for (shadowed = level->class_shadowed;
1554            shadowed;
1555            shadowed = TREE_CHAIN (shadowed))
1556         IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1557
1558       /* Find the next enclosing class, and recreate
1559          IDENTIFIER_CLASS_VALUEs appropriate for that class.  */
1560       b = level->level_chain;
1561       while (b && b->parm_flag != 2)
1562         b = b->level_chain;
1563
1564       if (b)
1565         for (shadowed = b->class_shadowed;
1566              shadowed;
1567              shadowed = TREE_CHAIN (shadowed))
1568           {
1569             tree t;
1570
1571             t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1572             while (t && BINDING_LEVEL (t) != b)
1573               t = TREE_CHAIN (t);
1574
1575             if (t)
1576               IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1577                 = BINDING_VALUE (t);
1578           }
1579     }
1580   else
1581     /* Remember to save what IDENTIFIER's were bound in this scope so we
1582        can recover from cache misses.  */
1583     {
1584       previous_class_type = current_class_type;
1585       previous_class_values = class_binding_level->class_shadowed;
1586     }
1587   for (shadowed = level->type_shadowed;
1588        shadowed;
1589        shadowed = TREE_CHAIN (shadowed))
1590     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1591
1592   /* Remove the bindings for all of the class-level declarations.  */
1593   for (shadowed = level->class_shadowed;
1594        shadowed;
1595        shadowed = TREE_CHAIN (shadowed))
1596     pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1597
1598   GNU_xref_end_scope ((HOST_WIDE_INT) class_binding_level,
1599                       (HOST_WIDE_INT) class_binding_level->level_chain,
1600                       class_binding_level->parm_flag,
1601                       class_binding_level->keep);
1602
1603   /* Now, pop out of the binding level which we created up in the
1604      `pushlevel_class' routine.  */
1605 #if defined(DEBUG_CP_BINDING_LEVELS)
1606   is_class_level = 1;
1607 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1608
1609   pop_binding_level ();
1610 }
1611
1612 /* We are entering the scope of a class.  Clear IDENTIFIER_CLASS_VALUE
1613    for any names in enclosing classes.  */
1614
1615 void
1616 clear_identifier_class_values ()
1617 {
1618   tree t;
1619
1620   if (!class_binding_level)
1621     return;
1622
1623   for (t = class_binding_level->class_shadowed;
1624        t;
1625        t = TREE_CHAIN (t))
1626     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1627 }
1628
1629 /* Returns non-zero if T is a virtual function table.  */
1630
1631 int
1632 vtable_decl_p (t, data)
1633      tree t;
1634      void *data ATTRIBUTE_UNUSED;
1635 {
1636   return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1637 }
1638
1639 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1640    functions.  */
1641
1642 int
1643 vtype_decl_p (t, data)
1644      tree t;
1645      void *data ATTRIBUTE_UNUSED;
1646 {
1647   return (TREE_CODE (t) == TYPE_DECL
1648           && TREE_TYPE (t) != error_mark_node
1649           && TYPE_LANG_SPECIFIC (TREE_TYPE (t))
1650           && CLASSTYPE_VSIZE (TREE_TYPE (t)));
1651 }
1652
1653 /* Return the declarations that are members of the namespace NS.  */
1654
1655 tree
1656 cp_namespace_decls (ns)
1657      tree ns;
1658 {
1659   return NAMESPACE_LEVEL (ns)->names;
1660 }
1661
1662 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1663    itself, calling F for each.  The DATA is passed to F as well.  */
1664
1665 static int
1666 walk_namespaces_r (namespace, f, data)
1667      tree namespace;
1668      walk_namespaces_fn f;
1669      void *data;
1670 {
1671   tree current;
1672   int result = 0;
1673
1674   result |= (*f) (namespace, data);
1675
1676   for (current = cp_namespace_decls (namespace);
1677        current;
1678        current = TREE_CHAIN (current))
1679     {
1680       if (TREE_CODE (current) != NAMESPACE_DECL
1681           || DECL_NAMESPACE_ALIAS (current))
1682         continue;
1683       if (!DECL_LANG_SPECIFIC (current))
1684         {
1685           /* Hmm. std. */
1686           my_friendly_assert (current == std_node, 393);
1687           continue;
1688         }
1689
1690       /* We found a namespace.  */
1691       result |= walk_namespaces_r (current, f, data);
1692     }
1693
1694   return result;
1695 }
1696
1697 /* Walk all the namespaces, calling F for each.  The DATA is passed to
1698    F as well.  */
1699
1700 int
1701 walk_namespaces (f, data)
1702      walk_namespaces_fn f;
1703      void *data;
1704 {
1705   return walk_namespaces_r (global_namespace, f, data);
1706 }
1707
1708 struct walk_globals_data {
1709   walk_globals_pred p;
1710   walk_globals_fn f;
1711   void *data;
1712 };
1713
1714 /* Walk the global declarations in NAMESPACE.  Whenever one is found
1715    for which P returns non-zero, call F with its address.  If any call
1716    to F returns a non-zero value, return a non-zero value.  */
1717
1718 static int
1719 walk_globals_r (namespace, data)
1720      tree namespace;
1721      void *data;
1722 {
1723   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1724   walk_globals_pred p = wgd->p;
1725   walk_globals_fn f = wgd->f;
1726   void *d = wgd->data;
1727   tree *t;
1728   int result = 0;
1729
1730   t = &NAMESPACE_LEVEL (namespace)->names;
1731
1732   while (*t)
1733     {
1734       tree glbl = *t;
1735
1736       if ((*p) (glbl, d))
1737         result |= (*f) (t, d);
1738
1739       /* If F changed *T, then *T still points at the next item to
1740          examine.  */
1741       if (*t == glbl)
1742         t = &TREE_CHAIN (*t);
1743     }
1744
1745   return result;
1746 }
1747
1748 /* Walk the global declarations.  Whenever one is found for which P
1749    returns non-zero, call F with its address.  If any call to F
1750    returns a non-zero value, return a non-zero value.  */
1751
1752 int
1753 walk_globals (p, f, data)
1754      walk_globals_pred p;
1755      walk_globals_fn f;
1756      void *data;
1757 {
1758   struct walk_globals_data wgd;
1759   wgd.p = p;
1760   wgd.f = f;
1761   wgd.data = data;
1762
1763   return walk_namespaces (walk_globals_r, &wgd);
1764 }
1765
1766 /* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
1767    DATA is non-NULL, this is the last time we will call
1768    wrapup_global_declarations for this NAMESPACE.  */
1769
1770 int
1771 wrapup_globals_for_namespace (namespace, data)
1772      tree namespace;
1773      void *data;
1774 {
1775   tree globals = cp_namespace_decls (namespace);
1776   int len = list_length (globals);
1777   tree *vec = (tree *) alloca (sizeof (tree) * len);
1778   int i;
1779   int result;
1780   tree decl;
1781   int last_time = (data != 0);
1782
1783   if (last_time && namespace == global_namespace)
1784     /* Let compile_file handle the global namespace.  */
1785     return 0;
1786
1787   /* Process the decls in reverse order--earliest first.
1788      Put them into VEC from back to front, then take out from front.  */
1789
1790   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1791     vec[len - i - 1] = decl;
1792
1793   if (last_time)
1794     {
1795       check_global_declarations (vec, len);
1796       return 0;
1797     }
1798
1799   /* Temporarily mark vtables as external.  That prevents
1800      wrapup_global_declarations from writing them out; we must process
1801      them ourselves in finish_vtable_vardecl.  */
1802   for (i = 0; i < len; ++i)
1803     if (vtable_decl_p (vec[i], /*data=*/0) && !DECL_EXTERNAL (vec[i]))
1804       {
1805         DECL_NOT_REALLY_EXTERN (vec[i]) = 1;
1806         DECL_EXTERNAL (vec[i]) = 1;
1807       }
1808
1809   /* Write out any globals that need to be output.  */
1810   result = wrapup_global_declarations (vec, len);
1811
1812   /* Undo the hack to DECL_EXTERNAL above.  */
1813   for (i = 0; i < len; ++i)
1814     if (vtable_decl_p (vec[i], /*data=*/0)
1815         && DECL_NOT_REALLY_EXTERN (vec[i]))
1816       {
1817         DECL_NOT_REALLY_EXTERN (vec[i]) = 0;
1818         DECL_EXTERNAL (vec[i]) = 0;
1819       }
1820
1821   return result;
1822 }
1823
1824 \f
1825 /* Mark ARG (which is really a struct binding_level **) for GC.  */
1826
1827 static void
1828 mark_binding_level (arg)
1829      void *arg;
1830 {
1831   struct binding_level *lvl = *(struct binding_level **)arg;
1832
1833   while (lvl)
1834     {
1835       ggc_mark_tree (lvl->names);
1836       ggc_mark_tree (lvl->tags);
1837       ggc_mark_tree (lvl->usings);
1838       ggc_mark_tree (lvl->using_directives);
1839       ggc_mark_tree (lvl->class_shadowed);
1840       ggc_mark_tree (lvl->type_shadowed);
1841       ggc_mark_tree (lvl->shadowed_labels);
1842       ggc_mark_tree (lvl->blocks);
1843       ggc_mark_tree (lvl->this_block);
1844       ggc_mark_tree (lvl->this_class);
1845       ggc_mark_tree (lvl->incomplete);
1846       ggc_mark_tree (lvl->dead_vars_from_for);
1847
1848       lvl = lvl->level_chain;
1849     }
1850 }
1851 \f
1852 /* For debugging.  */
1853 static int no_print_functions = 0;
1854 static int no_print_builtins = 0;
1855
1856 void
1857 print_binding_level (lvl)
1858      struct binding_level *lvl;
1859 {
1860   tree t;
1861   int i = 0, len;
1862   fprintf (stderr, " blocks=");
1863   fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
1864   fprintf (stderr, " n_incomplete=%d parm_flag=%d keep=%d",
1865            list_length (lvl->incomplete), lvl->parm_flag, lvl->keep);
1866   if (lvl->tag_transparent)
1867     fprintf (stderr, " tag-transparent");
1868   if (lvl->more_cleanups_ok)
1869     fprintf (stderr, " more-cleanups-ok");
1870   if (lvl->have_cleanups)
1871     fprintf (stderr, " have-cleanups");
1872   fprintf (stderr, "\n");
1873   if (lvl->names)
1874     {
1875       fprintf (stderr, " names:\t");
1876       /* We can probably fit 3 names to a line?  */
1877       for (t = lvl->names; t; t = TREE_CHAIN (t))
1878         {
1879           if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1880             continue;
1881           if (no_print_builtins
1882               && (TREE_CODE (t) == TYPE_DECL)
1883               && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
1884             continue;
1885
1886           /* Function decls tend to have longer names.  */
1887           if (TREE_CODE (t) == FUNCTION_DECL)
1888             len = 3;
1889           else
1890             len = 2;
1891           i += len;
1892           if (i > 6)
1893             {
1894               fprintf (stderr, "\n\t");
1895               i = len;
1896             }
1897           print_node_brief (stderr, "", t, 0);
1898           if (t == error_mark_node)
1899             break;
1900         }
1901       if (i)
1902         fprintf (stderr, "\n");
1903     }
1904   if (lvl->tags)
1905     {
1906       fprintf (stderr, " tags:\t");
1907       i = 0;
1908       for (t = lvl->tags; t; t = TREE_CHAIN (t))
1909         {
1910           if (TREE_PURPOSE (t) == NULL_TREE)
1911             len = 3;
1912           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
1913             len = 2;
1914           else
1915             len = 4;
1916           i += len;
1917           if (i > 5)
1918             {
1919               fprintf (stderr, "\n\t");
1920               i = len;
1921             }
1922           if (TREE_PURPOSE (t) == NULL_TREE)
1923             {
1924               print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
1925               fprintf (stderr, ">");
1926             }
1927           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
1928             print_node_brief (stderr, "", TREE_VALUE (t), 0);
1929           else
1930             {
1931               print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
1932               print_node_brief (stderr, "", TREE_VALUE (t), 0);
1933               fprintf (stderr, ">");
1934             }
1935         }
1936       if (i)
1937         fprintf (stderr, "\n");
1938     }
1939   if (lvl->class_shadowed)
1940     {
1941       fprintf (stderr, " class-shadowed:");
1942       for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
1943         {
1944           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1945         }
1946       fprintf (stderr, "\n");
1947     }
1948   if (lvl->type_shadowed)
1949     {
1950       fprintf (stderr, " type-shadowed:");
1951       for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1952         {
1953           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1954         }
1955       fprintf (stderr, "\n");
1956     }
1957 }
1958
1959 void
1960 print_other_binding_stack (stack)
1961      struct binding_level *stack;
1962 {
1963   struct binding_level *level;
1964   for (level = stack; level != global_binding_level; level = level->level_chain)
1965     {
1966       fprintf (stderr, "binding level ");
1967       fprintf (stderr, HOST_PTR_PRINTF, level);
1968       fprintf (stderr, "\n");
1969       print_binding_level (level);
1970     }
1971 }
1972
1973 void
1974 print_binding_stack ()
1975 {
1976   struct binding_level *b;
1977   fprintf (stderr, "current_binding_level=");
1978   fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
1979   fprintf (stderr, "\nclass_binding_level=");
1980   fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
1981   fprintf (stderr, "\nglobal_binding_level=");
1982   fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
1983   fprintf (stderr, "\n");
1984   if (class_binding_level)
1985     {
1986       for (b = class_binding_level; b; b = b->level_chain)
1987         if (b == current_binding_level)
1988           break;
1989       if (b)
1990         b = class_binding_level;
1991       else
1992         b = current_binding_level;
1993     }
1994   else
1995     b = current_binding_level;
1996   print_other_binding_stack (b);
1997   fprintf (stderr, "global:\n");
1998   print_binding_level (global_binding_level);
1999 }
2000
2001 /* Namespace binding access routines: The namespace_bindings field of
2002    the identifier is polymorphic, with three possible values:
2003    NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2004    indicating the BINDING_VALUE of global_namespace. */
2005
2006 /* Check whether the a binding for the name to scope is known.
2007    Assumes that the bindings of the name are already a list
2008    of bindings. Returns the binding found, or NULL_TREE. */
2009
2010 static tree
2011 find_binding (name, scope)
2012      tree name;
2013      tree scope;
2014 {
2015   tree iter, prev = NULL_TREE;
2016
2017   scope = ORIGINAL_NAMESPACE (scope);
2018
2019   for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2020        iter = TREE_CHAIN (iter))
2021     {
2022       my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2023       if (BINDING_SCOPE (iter) == scope)
2024         {
2025           /* Move binding found to the front of the list, so
2026              subsequent lookups will find it faster. */
2027           if (prev)
2028             {
2029               TREE_CHAIN (prev) = TREE_CHAIN (iter);
2030               TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2031               IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2032             }
2033           return iter;
2034         }
2035       prev = iter;
2036     }
2037   return NULL_TREE;
2038 }
2039
2040 /* Always returns a binding for name in scope. If the
2041    namespace_bindings is not a list, convert it to one first.
2042    If no binding is found, make a new one. */
2043
2044 tree
2045 binding_for_name (name, scope)
2046      tree name;
2047      tree scope;
2048 {
2049   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2050   tree result;
2051
2052   scope = ORIGINAL_NAMESPACE (scope);
2053
2054   if (b && TREE_CODE (b) != CPLUS_BINDING)
2055     {
2056       /* Get rid of optimization for global scope. */
2057       IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2058       BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2059       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2060     }
2061   if (b && (result = find_binding (name, scope)))
2062     return result;
2063   /* Not found, make a new one. */
2064   result = make_node (CPLUS_BINDING);
2065   TREE_CHAIN (result) = b;
2066   IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2067   BINDING_SCOPE (result) = scope;
2068   BINDING_TYPE (result) = NULL_TREE;
2069   BINDING_VALUE (result) = NULL_TREE;
2070   return result;
2071 }
2072
2073 /* Return the binding value for name in scope, considering that
2074    namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2075
2076 tree
2077 namespace_binding (name, scope)
2078      tree name;
2079      tree scope;
2080 {
2081   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2082   if (b == NULL_TREE)
2083     return NULL_TREE;
2084   if (scope == NULL_TREE)
2085     scope = global_namespace;
2086   if (TREE_CODE (b) != CPLUS_BINDING)
2087     return (scope == global_namespace) ? b : NULL_TREE;
2088   name = find_binding (name,scope);
2089   if (name == NULL_TREE)
2090     return name;
2091   return BINDING_VALUE (name);
2092 }
2093
2094 /* Set the binding value for name in scope. If modifying the binding
2095    of global_namespace is attempted, try to optimize it. */
2096
2097 void
2098 set_namespace_binding (name, scope, val)
2099      tree name;
2100      tree scope;
2101      tree val;
2102 {
2103   tree b;
2104
2105   if (scope == NULL_TREE)
2106     scope = global_namespace;
2107
2108   if (scope == global_namespace)
2109     {
2110       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2111       if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2112         {
2113           IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2114           return;
2115         }
2116     }
2117   b = binding_for_name (name, scope);
2118   BINDING_VALUE (b) = val;
2119 }
2120
2121 /* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
2122    select a name that is unique to this compilation unit.  */
2123
2124 void
2125 push_namespace (name)
2126      tree name;
2127 {
2128   tree d = NULL_TREE;
2129   int need_new = 1;
2130   int implicit_use = 0;
2131   int global = 0;
2132   if (!global_namespace)
2133     {
2134       /* This must be ::. */
2135       my_friendly_assert (name == get_identifier ("::"), 377);
2136       global = 1;
2137     }
2138   else if (!name)
2139     {
2140       /* The name of anonymous namespace is unique for the translation
2141          unit.  */
2142       if (!anonymous_namespace_name)
2143         anonymous_namespace_name = get_file_function_name ('N');
2144       name = anonymous_namespace_name;
2145       d = IDENTIFIER_NAMESPACE_VALUE (name);
2146       if (d)
2147         /* Reopening anonymous namespace.  */
2148         need_new = 0;
2149       implicit_use = 1;
2150     }
2151   else if (current_namespace == global_namespace
2152            && name == DECL_NAME (std_node))
2153     {
2154       in_std++;
2155       return;
2156     }
2157   else
2158     {
2159       /* Check whether this is an extended namespace definition. */
2160       d = IDENTIFIER_NAMESPACE_VALUE (name);
2161       if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2162         {
2163           need_new = 0;
2164           if (DECL_NAMESPACE_ALIAS (d))
2165             {
2166               cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
2167                         d, DECL_NAMESPACE_ALIAS (d));
2168               d = DECL_NAMESPACE_ALIAS (d);
2169             }
2170         }
2171     }
2172
2173   if (need_new)
2174     {
2175       /* Make a new namespace, binding the name to it. */
2176       d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2177       /* The global namespace is not pushed, and the global binding
2178          level is set elsewhere.  */
2179       if (!global)
2180         {
2181           d = pushdecl (d);
2182           pushlevel (0);
2183           declare_namespace_level ();
2184           NAMESPACE_LEVEL (d) = current_binding_level;
2185         }
2186     }
2187   else
2188     resume_binding_level (NAMESPACE_LEVEL (d));
2189
2190   if (implicit_use)
2191     do_using_directive (d);
2192   /* Enter the name space. */
2193   current_namespace = d;
2194 }
2195
2196 /* Pop from the scope of the current namespace.  */
2197
2198 void
2199 pop_namespace ()
2200 {
2201   if (current_namespace == global_namespace)
2202     {
2203       my_friendly_assert (in_std>0, 980421);
2204       in_std--;
2205       return;
2206     }
2207   current_namespace = CP_DECL_CONTEXT (current_namespace);
2208   /* The binding level is not popped, as it might be re-opened later.  */
2209   suspend_binding_level ();
2210 }
2211
2212 /* Push into the scope of the namespace NS, even if it is deeply
2213    nested within another namespace.  */
2214
2215 void
2216 push_nested_namespace (ns)
2217      tree ns;
2218 {
2219   if (ns == global_namespace)
2220     push_to_top_level ();
2221   else
2222     {
2223       push_nested_namespace (CP_DECL_CONTEXT (ns));
2224       push_namespace (DECL_NAME (ns));
2225     }
2226 }
2227
2228 /* Pop back from the scope of the namespace NS, which was previously
2229    entered with push_nested_namespace.  */
2230
2231 void
2232 pop_nested_namespace (ns)
2233      tree ns;
2234 {
2235   while (ns != global_namespace)
2236     {
2237       pop_namespace ();
2238       ns = CP_DECL_CONTEXT (ns);
2239     }
2240
2241   pop_from_top_level ();
2242 }
2243
2244 \f
2245 /* Subroutines for reverting temporarily to top-level for instantiation
2246    of templates and such.  We actually need to clear out the class- and
2247    local-value slots of all identifiers, so that only the global values
2248    are at all visible.  Simply setting current_binding_level to the global
2249    scope isn't enough, because more binding levels may be pushed.  */
2250 struct saved_scope *scope_chain;
2251
2252 /* Mark ST for GC.  */
2253
2254 static void
2255 mark_stmt_tree (st)
2256      struct stmt_tree *st;
2257 {
2258   ggc_mark_tree (st->x_last_stmt);
2259   ggc_mark_tree (st->x_last_expr_type);
2260 }
2261
2262 /* Mark ARG (which is really a struct saved_scope **) for GC.  */
2263
2264 static void
2265 mark_saved_scope (arg)
2266      void *arg;
2267 {
2268   struct saved_scope *t = *(struct saved_scope **)arg;
2269   while (t)
2270     {
2271       mark_binding_level (&t->class_bindings);
2272       ggc_mark_tree (t->old_bindings);
2273       ggc_mark_tree (t->old_namespace);
2274       ggc_mark_tree (t->class_name);
2275       ggc_mark_tree (t->class_type);
2276       ggc_mark_tree (t->access_specifier);
2277       ggc_mark_tree (t->function_decl);
2278       if (t->lang_base)
2279         ggc_mark_tree_varray (t->lang_base);
2280       ggc_mark_tree (t->lang_name);
2281       ggc_mark_tree (t->x_function_parms);
2282       ggc_mark_tree (t->template_parms);
2283       ggc_mark_tree (t->x_previous_class_type);
2284       ggc_mark_tree (t->x_previous_class_values);
2285       ggc_mark_tree (t->x_saved_tree);
2286       ggc_mark_tree (t->incomplete);
2287       ggc_mark_tree (t->lookups);
2288
2289       mark_stmt_tree (&t->x_stmt_tree);
2290       mark_binding_level (&t->bindings);
2291       t = t->prev;
2292     }
2293 }
2294
2295 static tree
2296 store_bindings (names, old_bindings)
2297      tree names, old_bindings;
2298 {
2299   tree t;
2300   for (t = names; t; t = TREE_CHAIN (t))
2301     {
2302       tree binding, t1, id;
2303
2304       if (TREE_CODE (t) == TREE_LIST)
2305         id = TREE_PURPOSE (t);
2306       else
2307         id = DECL_NAME (t);
2308
2309       if (!id
2310           /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2311              we have no IDENTIFIER_BINDING if we have left the class
2312              scope, but cached the class-level declarations.  */
2313           || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2314         continue;
2315
2316       for (t1 = old_bindings; t1; t1 = TREE_CHAIN (t1))
2317         if (TREE_VEC_ELT (t1, 0) == id)
2318           goto skip_it;
2319
2320       binding = make_tree_vec (4);
2321
2322       if (id)
2323         {
2324           my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2325           TREE_VEC_ELT (binding, 0) = id;
2326           TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2327           TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2328           TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2329           IDENTIFIER_BINDING (id) = NULL_TREE;
2330           IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2331         }
2332       TREE_CHAIN (binding) = old_bindings;
2333       old_bindings = binding;
2334     skip_it:
2335       ;
2336     }
2337   return old_bindings;
2338 }
2339
2340 void
2341 maybe_push_to_top_level (pseudo)
2342      int pseudo;
2343 {
2344   struct saved_scope *s;
2345   struct binding_level *b;
2346   tree old_bindings;
2347   int need_pop;
2348
2349   s = (struct saved_scope *) xcalloc (1, sizeof (struct saved_scope));
2350
2351   b = scope_chain ? current_binding_level : 0;
2352
2353   /* If we're in the middle of some function, save our state.  */
2354   if (cfun)
2355     {
2356       need_pop = 1;
2357       push_function_context_to (NULL_TREE);
2358     }
2359   else
2360     need_pop = 0;
2361
2362   old_bindings = NULL_TREE;
2363   if (scope_chain && previous_class_type)
2364     old_bindings = store_bindings (previous_class_values, old_bindings);
2365
2366   /* Have to include global_binding_level, because class-level decls
2367      aren't listed anywhere useful.  */
2368   for (; b; b = b->level_chain)
2369     {
2370       tree t;
2371
2372       /* Template IDs are inserted into the global level. If they were
2373          inserted into namespace level, finish_file wouldn't find them
2374          when doing pending instantiations. Therefore, don't stop at
2375          namespace level, but continue until :: .  */
2376       if (b == global_binding_level || (pseudo && b->pseudo_global))
2377         break;
2378
2379       old_bindings = store_bindings (b->names, old_bindings);
2380       /* We also need to check class_shadowed to save class-level type
2381          bindings, since pushclass doesn't fill in b->names.  */
2382       if (b->parm_flag == 2)
2383         old_bindings = store_bindings (b->class_shadowed, old_bindings);
2384
2385       /* Unwind type-value slots back to top level.  */
2386       for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2387         SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2388     }
2389   s->prev = scope_chain;
2390   s->old_bindings = old_bindings;
2391   s->bindings = b;
2392   s->need_pop_function_context = need_pop;
2393   s->function_decl = current_function_decl;
2394
2395   scope_chain = s;
2396   current_function_decl = NULL_TREE;
2397   VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2398   current_lang_stack = &VARRAY_TREE (current_lang_base, 0);
2399   current_lang_name = lang_name_cplusplus;
2400   strict_prototype = strict_prototypes_lang_cplusplus;
2401   current_namespace = global_namespace;
2402 }
2403
2404 void
2405 push_to_top_level ()
2406 {
2407   maybe_push_to_top_level (0);
2408 }
2409
2410 void
2411 pop_from_top_level ()
2412 {
2413   struct saved_scope *s = scope_chain;
2414   tree t;
2415
2416   /* Clear out class-level bindings cache.  */
2417   if (previous_class_type)
2418     invalidate_class_lookup_cache ();
2419
2420   VARRAY_FREE (current_lang_base);
2421
2422   scope_chain = s->prev;
2423   for (t = s->old_bindings; t; t = TREE_CHAIN (t))
2424     {
2425       tree id = TREE_VEC_ELT (t, 0);
2426       if (id)
2427         {
2428           SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2429           IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2430           IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2431         }
2432     }
2433
2434   if (current_lang_name == lang_name_cplusplus)
2435     strict_prototype = strict_prototypes_lang_cplusplus;
2436   else if (current_lang_name == lang_name_c)
2437     strict_prototype = strict_prototypes_lang_c;
2438
2439   /* If we were in the middle of compiling a function, restore our
2440      state.  */
2441   if (s->need_pop_function_context)
2442     pop_function_context_from (NULL_TREE);
2443   current_function_decl = s->function_decl;
2444
2445   free (s);
2446 }
2447 \f
2448 /* Push a definition of struct, union or enum tag "name".
2449    into binding_level "b".   "type" should be the type node,
2450    We assume that the tag "name" is not already defined.
2451
2452    Note that the definition may really be just a forward reference.
2453    In that case, the TYPE_SIZE will be a NULL_TREE.
2454
2455    C++ gratuitously puts all these tags in the name space.  */
2456
2457 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2458    record the shadowed value for this binding contour.  TYPE is
2459    the type that ID maps to.  */
2460
2461 static void
2462 set_identifier_type_value_with_scope (id, type, b)
2463      tree id;
2464      tree type;
2465      struct binding_level *b;
2466 {
2467   if (!b->namespace_p)
2468     {
2469       /* Shadow the marker, not the real thing, so that the marker
2470          gets restored later. */
2471       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2472       b->type_shadowed
2473         = tree_cons (id, old_type_value, b->type_shadowed);
2474     }
2475   else
2476     {
2477       tree binding = binding_for_name (id, current_namespace);
2478       BINDING_TYPE (binding) = type;
2479       /* Store marker instead of real type. */
2480       type = global_type_node;
2481     }
2482   SET_IDENTIFIER_TYPE_VALUE (id, type);
2483 }
2484
2485 /* As set_identifier_type_value_with_scope, but using current_binding_level.  */
2486
2487 void
2488 set_identifier_type_value (id, type)
2489      tree id;
2490      tree type;
2491 {
2492   set_identifier_type_value_with_scope (id, type, current_binding_level);
2493 }
2494
2495 /* Return the type associated with id. */
2496
2497 tree
2498 identifier_type_value (id)
2499      tree id;
2500 {
2501   /* There is no type with that name, anywhere. */
2502   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2503     return NULL_TREE;
2504   /* This is not the type marker, but the real thing. */
2505   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2506     return REAL_IDENTIFIER_TYPE_VALUE (id);
2507   /* Have to search for it. It must be on the global level, now.
2508      Ask lookup_name not to return non-types. */
2509   id = lookup_name_real (id, 2, 1, 0);
2510   if (id)
2511     return TREE_TYPE (id);
2512   return NULL_TREE;
2513 }
2514
2515 /* Pop off extraneous binding levels left over due to syntax errors.
2516
2517    We don't pop past namespaces, as they might be valid.  */
2518
2519 void
2520 pop_everything ()
2521 {
2522 #ifdef DEBUG_CP_BINDING_LEVELS
2523   fprintf (stderr, "XXX entering pop_everything ()\n");
2524 #endif
2525   while (!toplevel_bindings_p ())
2526     {
2527       if (current_binding_level->parm_flag == 2)
2528         pop_nested_class ();
2529       else
2530         poplevel (0, 0, 0);
2531     }
2532 #ifdef DEBUG_CP_BINDING_LEVELS
2533   fprintf (stderr, "XXX leaving pop_everything ()\n");
2534 #endif
2535 }
2536
2537 /* The type TYPE is being declared.  If it is a class template, or a
2538    specialization of a class template, do any processing required and
2539    perform error-checking.  If IS_FRIEND is non-zero, this TYPE is
2540    being declared a friend.  B is the binding level at which this TYPE
2541    should be bound.
2542
2543    Returns the TYPE_DECL for TYPE, which may have been altered by this
2544    processing.  */
2545
2546 static tree
2547 maybe_process_template_type_declaration (type, globalize, b)
2548      tree type;
2549      int globalize;
2550      struct binding_level* b;
2551 {
2552   tree decl = TYPE_NAME (type);
2553
2554   if (processing_template_parmlist)
2555     /* You can't declare a new template type in a template parameter
2556        list.  But, you can declare a non-template type:
2557
2558          template <class A*> struct S;
2559
2560        is a forward-declaration of `A'.  */
2561     ;
2562   else
2563     {
2564       maybe_check_template_type (type);
2565
2566       my_friendly_assert (IS_AGGR_TYPE (type)
2567                           || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2568
2569
2570       if (processing_template_decl)
2571         {
2572           /* This may change after the call to
2573              push_template_decl_real, but we want the original value.  */
2574           tree name = DECL_NAME (decl);
2575
2576           decl = push_template_decl_real (decl, globalize);
2577           /* If the current binding level is the binding level for the
2578              template parameters (see the comment in
2579              begin_template_parm_list) and the enclosing level is a class
2580              scope, and we're not looking at a friend, push the
2581              declaration of the member class into the class scope.  In the
2582              friend case, push_template_decl will already have put the
2583              friend into global scope, if appropriate.  */
2584           if (TREE_CODE (type) != ENUMERAL_TYPE
2585               && !globalize && b->pseudo_global
2586               && b->level_chain->parm_flag == 2)
2587             {
2588               finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2589               /* Put this tag on the list of tags for the class, since
2590                  that won't happen below because B is not the class
2591                  binding level, but is instead the pseudo-global level.  */
2592               b->level_chain->tags =
2593                 tree_cons (name, type, b->level_chain->tags);
2594               if (TYPE_SIZE (current_class_type) == NULL_TREE)
2595                 CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2596             }
2597         }
2598     }
2599
2600   return decl;
2601 }
2602
2603 /* In C++, you don't have to write `struct S' to refer to `S'; you
2604    can just use `S'.  We accomplish this by creating a TYPE_DECL as
2605    if the user had written `typedef struct S S'.  Create and return
2606    the TYPE_DECL for TYPE.  */
2607
2608 tree
2609 create_implicit_typedef (name, type)
2610      tree name;
2611      tree type;
2612 {
2613   tree decl;
2614
2615   decl = build_decl (TYPE_DECL, name, type);
2616   SET_DECL_ARTIFICIAL (decl);
2617   /* There are other implicit type declarations, like the one *within*
2618      a class that allows you to write `S::S'.  We must distinguish
2619      amongst these.  */
2620   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2621   TYPE_NAME (type) = decl;
2622
2623   return decl;
2624 }
2625
2626 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2627    Normally put it into the inner-most non-tag-transparent scope,
2628    but if GLOBALIZE is true, put it in the inner-most non-class scope.
2629    The latter is needed for implicit declarations.  */
2630
2631 void
2632 pushtag (name, type, globalize)
2633      tree name, type;
2634      int globalize;
2635 {
2636   register struct binding_level *b;
2637
2638   b = current_binding_level;
2639   while (b->tag_transparent
2640          || (globalize && b->parm_flag == 2))
2641     b = b->level_chain;
2642
2643   b->tags = tree_cons (name, type, b->tags);
2644
2645   if (name)
2646     {
2647       /* Do C++ gratuitous typedefing.  */
2648       if (IDENTIFIER_TYPE_VALUE (name) != type)
2649         {
2650           register tree d = NULL_TREE;
2651           int in_class = 0;
2652           tree context = TYPE_CONTEXT (type);
2653
2654           if (! context)
2655             {
2656               tree cs = current_scope ();
2657
2658               if (! globalize)
2659                 context = cs;
2660               else if (cs != NULL_TREE
2661                        && TREE_CODE_CLASS (TREE_CODE (cs)) == 't')
2662                 /* When declaring a friend class of a local class, we want
2663                    to inject the newly named class into the scope
2664                    containing the local class, not the namespace scope.  */
2665                 context = hack_decl_function_context (get_type_decl (cs));
2666             }
2667           if (!context)
2668             context = current_namespace;
2669
2670           if ((b->pseudo_global && b->level_chain->parm_flag == 2)
2671               || b->parm_flag == 2)
2672             in_class = 1;
2673
2674           if (current_lang_name == lang_name_java)
2675             TYPE_FOR_JAVA (type) = 1;
2676
2677           d = create_implicit_typedef (name, type);
2678           DECL_CONTEXT (d) = FROB_CONTEXT (context);
2679           if (! in_class)
2680             set_identifier_type_value_with_scope (name, type, b);
2681
2682           d = maybe_process_template_type_declaration (type,
2683                                                        globalize, b);
2684
2685           if (b->parm_flag == 2)
2686             {
2687               if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2688                 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2689                    class.  But if it's a member template class, we
2690                    want the TEMPLATE_DECL, not the TYPE_DECL, so this
2691                    is done later.  */
2692                 finish_member_declaration (d);
2693               else
2694                 pushdecl_class_level (d);
2695             }
2696           else
2697             d = pushdecl_with_scope (d, b);
2698
2699           if (ANON_AGGRNAME_P (name))
2700             DECL_IGNORED_P (d) = 1;
2701
2702           TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2703           DECL_ASSEMBLER_NAME (d) = DECL_NAME (d);
2704           if (!uses_template_parms (type))
2705             DECL_ASSEMBLER_NAME (d)
2706               = get_identifier (build_overload_name (type, 1, 1));
2707         }
2708       if (b->parm_flag == 2)
2709         {
2710           if (TYPE_SIZE (current_class_type) == NULL_TREE)
2711             CLASSTYPE_TAGS (current_class_type) = b->tags;
2712         }
2713     }
2714
2715   if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2716     /* Use the canonical TYPE_DECL for this node.  */
2717     TYPE_STUB_DECL (type) = TYPE_NAME (type);
2718   else
2719     {
2720       /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2721          will be the tagged type we just added to the current
2722          binding level.  This fake NULL-named TYPE_DECL node helps
2723          dwarfout.c to know when it needs to output a
2724          representation of a tagged type, and it also gives us a
2725          convenient place to record the "scope start" address for
2726          the tagged type.  */
2727
2728       tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2729       TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2730     }
2731 }
2732
2733 /* Counter used to create anonymous type names.  */
2734
2735 static int anon_cnt = 0;
2736
2737 /* Return an IDENTIFIER which can be used as a name for
2738    anonymous structs and unions.  */
2739
2740 tree
2741 make_anon_name ()
2742 {
2743   char buf[32];
2744
2745   sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2746   return get_identifier (buf);
2747 }
2748
2749 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2750    This keeps dbxout from getting confused.  */
2751
2752 void
2753 clear_anon_tags ()
2754 {
2755   register struct binding_level *b;
2756   register tree tags;
2757   static int last_cnt = 0;
2758
2759   /* Fast out if no new anon names were declared.  */
2760   if (last_cnt == anon_cnt)
2761     return;
2762
2763   b = current_binding_level;
2764   while (b->tag_transparent)
2765     b = b->level_chain;
2766   tags = b->tags;
2767   while (tags)
2768     {
2769       /* A NULL purpose means we have already processed all tags
2770          from here to the end of the list.  */
2771       if (TREE_PURPOSE (tags) == NULL_TREE)
2772         break;
2773       if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2774         TREE_PURPOSE (tags) = NULL_TREE;
2775       tags = TREE_CHAIN (tags);
2776     }
2777   last_cnt = anon_cnt;
2778 }
2779 \f
2780 /* Subroutine of duplicate_decls: return truthvalue of whether
2781    or not types of these decls match.
2782
2783    For C++, we must compare the parameter list so that `int' can match
2784    `int&' in a parameter position, but `int&' is not confused with
2785    `const int&'.  */
2786
2787 int
2788 decls_match (newdecl, olddecl)
2789      tree newdecl, olddecl;
2790 {
2791   int types_match;
2792
2793   if (newdecl == olddecl)
2794     return 1;
2795
2796   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
2797     /* If the two DECLs are not even the same kind of thing, we're not
2798        interested in their types.  */
2799     return 0;
2800
2801   if (TREE_CODE (newdecl) == FUNCTION_DECL)
2802     {
2803       tree f1 = TREE_TYPE (newdecl);
2804       tree f2 = TREE_TYPE (olddecl);
2805       tree p1 = TYPE_ARG_TYPES (f1);
2806       tree p2 = TYPE_ARG_TYPES (f2);
2807
2808       if (DECL_REAL_CONTEXT (newdecl) != DECL_REAL_CONTEXT (olddecl)
2809           && ! (DECL_LANGUAGE (newdecl) == lang_c
2810                 && DECL_LANGUAGE (olddecl) == lang_c))
2811         return 0;
2812
2813       /* When we parse a static member function definition,
2814          we put together a FUNCTION_DECL which thinks its type
2815          is METHOD_TYPE.  Change that to FUNCTION_TYPE, and
2816          proceed.  */
2817       if (TREE_CODE (f1) == METHOD_TYPE && DECL_STATIC_FUNCTION_P (olddecl))
2818         revert_static_member_fn (&newdecl, &f1, &p1);
2819       else if (TREE_CODE (f2) == METHOD_TYPE
2820                && DECL_STATIC_FUNCTION_P (newdecl))
2821         revert_static_member_fn (&olddecl, &f2, &p2);
2822
2823       /* Here we must take care of the case where new default
2824          parameters are specified.  Also, warn if an old
2825          declaration becomes ambiguous because default
2826          parameters may cause the two to be ambiguous.  */
2827       if (TREE_CODE (f1) != TREE_CODE (f2))
2828         {
2829           if (TREE_CODE (f1) == OFFSET_TYPE)
2830             cp_compiler_error ("`%D' redeclared as member function", newdecl);
2831           else
2832             cp_compiler_error ("`%D' redeclared as non-member function", newdecl);
2833           return 0;
2834         }
2835
2836       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
2837         {
2838           if (! strict_prototypes_lang_c && DECL_LANGUAGE (olddecl) == lang_c
2839               && p2 == NULL_TREE)
2840             {
2841               types_match = self_promoting_args_p (p1);
2842               if (p1 == void_list_node)
2843                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2844             }
2845           else if (!strict_prototypes_lang_c && DECL_LANGUAGE (olddecl)==lang_c
2846                    && DECL_LANGUAGE (newdecl) == lang_c && p1 == NULL_TREE)
2847             {
2848               types_match = self_promoting_args_p (p2);
2849               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2850             }
2851           else
2852             types_match = compparms (p1, p2);
2853         }
2854       else
2855         types_match = 0;
2856     }
2857   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2858     {
2859       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
2860                                 DECL_TEMPLATE_PARMS (olddecl)))
2861         return 0;
2862
2863       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2864         types_match = 1;
2865       else
2866         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
2867                                    DECL_TEMPLATE_RESULT (newdecl));
2868     }
2869   else
2870     {
2871       if (TREE_TYPE (newdecl) == error_mark_node)
2872         types_match = TREE_TYPE (olddecl) == error_mark_node;
2873       else if (TREE_TYPE (olddecl) == NULL_TREE)
2874         types_match = TREE_TYPE (newdecl) == NULL_TREE;
2875       else if (TREE_TYPE (newdecl) == NULL_TREE)
2876         types_match = 0;
2877       else
2878         types_match = comptypes (TREE_TYPE (newdecl),
2879                                  TREE_TYPE (olddecl),
2880                                  COMPARE_REDECLARATION);
2881     }
2882
2883   return types_match;
2884 }
2885
2886 /* If NEWDECL is `static' and an `extern' was seen previously,
2887    warn about it.  OLDDECL is the previous declaration.
2888
2889    Note that this does not apply to the C++ case of declaring
2890    a variable `extern const' and then later `const'.
2891
2892    Don't complain about built-in functions, since they are beyond
2893    the user's control.  */
2894
2895 static void
2896 warn_extern_redeclared_static (newdecl, olddecl)
2897      tree newdecl, olddecl;
2898 {
2899   static const char *explicit_extern_static_warning
2900     = "`%D' was declared `extern' and later `static'";
2901   static const char *implicit_extern_static_warning
2902     = "`%D' was declared implicitly `extern' and later `static'";
2903
2904   tree name;
2905
2906   if (TREE_CODE (newdecl) == TYPE_DECL
2907       || TREE_CODE (newdecl) == TEMPLATE_DECL)
2908     return;
2909
2910   /* Don't get confused by static member functions; that's a different
2911      use of `static'.  */
2912   if (TREE_CODE (newdecl) == FUNCTION_DECL
2913       && DECL_STATIC_FUNCTION_P (newdecl))
2914     return;
2915
2916   /* If the old declaration was `static', or the new one isn't, then
2917      then everything is OK.  */
2918   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
2919     return;
2920
2921   /* It's OK to declare a builtin function as `static'.  */
2922   if (TREE_CODE (olddecl) == FUNCTION_DECL
2923       && DECL_ARTIFICIAL (olddecl))
2924     return;
2925
2926   name = DECL_ASSEMBLER_NAME (newdecl);
2927   cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
2928               ? implicit_extern_static_warning
2929               : explicit_extern_static_warning, newdecl);
2930   cp_pedwarn_at ("previous declaration of `%D'", olddecl);
2931 }
2932
2933 /* Handle when a new declaration NEWDECL has the same name as an old
2934    one OLDDECL in the same binding contour.  Prints an error message
2935    if appropriate.
2936
2937    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
2938    Otherwise, return 0.  */
2939
2940 int
2941 duplicate_decls (newdecl, olddecl)
2942      tree newdecl, olddecl;
2943 {
2944   unsigned olddecl_uid = DECL_UID (olddecl);
2945   int olddecl_friend = 0, types_match = 0;
2946   int new_defines_function = 0;
2947
2948   if (newdecl == olddecl)
2949     return 1;
2950
2951   types_match = decls_match (newdecl, olddecl);
2952
2953   /* If either the type of the new decl or the type of the old decl is an
2954      error_mark_node, then that implies that we have already issued an
2955      error (earlier) for some bogus type specification, and in that case,
2956      it is rather pointless to harass the user with yet more error message
2957      about the same declaration, so just pretend the types match here.  */
2958   if (TREE_TYPE (newdecl) == error_mark_node
2959       || TREE_TYPE (olddecl) == error_mark_node)
2960     types_match = 1;
2961
2962   /* Check for redeclaration and other discrepancies. */
2963   if (TREE_CODE (olddecl) == FUNCTION_DECL
2964       && DECL_ARTIFICIAL (olddecl))
2965     {
2966       if (TREE_CODE (newdecl) != FUNCTION_DECL)
2967         {
2968           /* If you declare a built-in or predefined function name as static,
2969              the old definition is overridden, but optionally warn this was a
2970              bad choice of name.  */
2971           if (! TREE_PUBLIC (newdecl))
2972             {
2973               if (warn_shadow)
2974                 cp_warning ("shadowing %s function `%#D'",
2975                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
2976                             olddecl);
2977               /* Discard the old built-in function.  */
2978               return 0;
2979             }
2980           /* If the built-in is not ansi, then programs can override
2981              it even globally without an error.  */
2982           else if (! DECL_BUILT_IN (olddecl))
2983             cp_warning ("library function `%#D' redeclared as non-function `%#D'",
2984                         olddecl, newdecl);
2985           else
2986             {
2987               cp_error ("declaration of `%#D'", newdecl);
2988               cp_error ("conflicts with built-in declaration `%#D'",
2989                         olddecl);
2990             }
2991           return 0;
2992         }
2993       else if (!types_match)
2994         {
2995           if ((DECL_LANGUAGE (newdecl) == lang_c
2996                && DECL_LANGUAGE (olddecl) == lang_c)
2997               || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
2998                             TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
2999             {
3000               /* A near match; override the builtin.  */
3001
3002               if (TREE_PUBLIC (newdecl))
3003                 {
3004                   cp_warning ("new declaration `%#D'", newdecl);
3005                   cp_warning ("ambiguates built-in declaration `%#D'",
3006                               olddecl);
3007                 }
3008               else if (warn_shadow)
3009                 cp_warning ("shadowing %s function `%#D'",
3010                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3011                             olddecl);
3012             }
3013           else
3014             /* Discard the old built-in function.  */
3015             return 0;
3016         }
3017
3018       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3019         {
3020           /* If a builtin function is redeclared as `static', merge
3021              the declarations, but make the original one static.  */
3022           DECL_THIS_STATIC (olddecl) = 1;
3023           TREE_PUBLIC (olddecl) = 0;
3024
3025           /* Make the olddeclaration consistent with the new one so that
3026              all remnants of the builtin-ness of this function will be
3027              banished.  */
3028           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3029           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3030           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3031           SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (newdecl),
3032                                        newdecl);
3033         }
3034     }
3035   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3036     {
3037       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3038            && TREE_CODE (newdecl) != TYPE_DECL
3039            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3040                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3041           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3042               && TREE_CODE (olddecl) != TYPE_DECL
3043               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3044                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3045                         == TYPE_DECL))))
3046         {
3047           /* We do nothing special here, because C++ does such nasty
3048              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
3049              get shadowed, and know that if we need to find a TYPE_DECL
3050              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3051              slot of the identifier.  */
3052           return 0;
3053         }
3054
3055       if ((TREE_CODE (newdecl) == FUNCTION_DECL
3056            && DECL_FUNCTION_TEMPLATE_P (olddecl))
3057           || (TREE_CODE (olddecl) == FUNCTION_DECL
3058               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3059         return 0;
3060
3061       cp_error ("`%#D' redeclared as different kind of symbol", newdecl);
3062       if (TREE_CODE (olddecl) == TREE_LIST)
3063         olddecl = TREE_VALUE (olddecl);
3064       cp_error_at ("previous declaration of `%#D'", olddecl);
3065
3066       /* New decl is completely inconsistent with the old one =>
3067          tell caller to replace the old one.  */
3068
3069       return 0;
3070     }
3071   else if (!types_match)
3072     {
3073       if (DECL_REAL_CONTEXT (newdecl) != DECL_REAL_CONTEXT (olddecl))
3074         /* These are certainly not duplicate declarations; they're
3075            from different scopes.  */
3076         return 0;
3077
3078       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3079         {
3080           /* The name of a class template may not be declared to refer to
3081              any other template, class, function, object, namespace, value,
3082              or type in the same scope.  */
3083           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3084               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3085             {
3086               cp_error ("declaration of template `%#D'", newdecl);
3087               cp_error_at ("conflicts with previous declaration `%#D'",
3088                            olddecl);
3089             }
3090           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3091                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3092                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3093                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3094                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3095                                            DECL_TEMPLATE_PARMS (olddecl)))
3096             {
3097               cp_error ("new declaration `%#D'", newdecl);
3098               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3099             }
3100           return 0;
3101         }
3102       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3103         {
3104           if (DECL_LANGUAGE (newdecl) == lang_c
3105               && DECL_LANGUAGE (olddecl) == lang_c)
3106             {
3107               cp_error ("declaration of C function `%#D' conflicts with",
3108                         newdecl);
3109               cp_error_at ("previous declaration `%#D' here", olddecl);
3110             }
3111           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3112                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3113             {
3114               cp_error ("new declaration `%#D'", newdecl);
3115               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3116             }
3117           else
3118             return 0;
3119         }
3120
3121       /* Already complained about this, so don't do so again.  */
3122       else if (current_class_type == NULL_TREE
3123           || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3124         {
3125           cp_error ("conflicting types for `%#D'", newdecl);
3126           cp_error_at ("previous declaration as `%#D'", olddecl);
3127         }
3128     }
3129   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3130             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3131                  && (!DECL_TEMPLATE_INFO (newdecl)
3132                      || (DECL_TI_TEMPLATE (newdecl)
3133                          != DECL_TI_TEMPLATE (olddecl))))
3134                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3135                     && (!DECL_TEMPLATE_INFO (olddecl)
3136                         || (DECL_TI_TEMPLATE (olddecl)
3137                             != DECL_TI_TEMPLATE (newdecl))))))
3138     /* It's OK to have a template specialization and a non-template
3139        with the same type, or to have specializations of two
3140        different templates with the same type.  Note that if one is a
3141        specialization, and the other is an instantiation of the same
3142        template, that we do not exit at this point.  That situation
3143        can occur if we instantiate a template class, and then
3144        specialize one of its methods.  This situation is legal, but
3145        the declarations must be merged in the usual way.  */
3146     return 0;
3147   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3148            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3149                 && !DECL_USE_TEMPLATE (newdecl))
3150                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3151                    && !DECL_USE_TEMPLATE (olddecl))))
3152     /* One of the declarations is a template instantiation, and the
3153        other is not a template at all.  That's OK.  */
3154     return 0;
3155   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3156            && DECL_NAMESPACE_ALIAS (newdecl)
3157            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3158     /* Redeclaration of namespace alias, ignore it. */
3159     return 1;
3160   else
3161     {
3162       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3163       if (errmsg)
3164         {
3165           cp_error (errmsg, newdecl);
3166           if (DECL_NAME (olddecl) != NULL_TREE)
3167             cp_error_at ((DECL_INITIAL (olddecl)
3168                           && namespace_bindings_p ())
3169                          ? "`%#D' previously defined here"
3170                          : "`%#D' previously declared here", olddecl);
3171         }
3172       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3173                && DECL_INITIAL (olddecl) != NULL_TREE
3174                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3175                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3176         {
3177           /* Prototype decl follows defn w/o prototype.  */
3178           cp_warning_at ("prototype for `%#D'", newdecl);
3179           cp_warning_at ("follows non-prototype definition here", olddecl);
3180         }
3181       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3182                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3183         {
3184           /* extern "C" int foo ();
3185              int foo () { bar (); }
3186              is OK.  */
3187           if (current_lang_stack
3188               == &VARRAY_TREE (current_lang_base, 0))
3189             DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3190           else
3191             {
3192               cp_error_at ("previous declaration of `%#D' with %L linkage",
3193                            olddecl, DECL_LANGUAGE (olddecl));
3194               cp_error ("conflicts with new declaration with %L linkage",
3195                         DECL_LANGUAGE (newdecl));
3196             }
3197         }
3198
3199       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3200         ;
3201       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3202         {
3203           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3204           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3205           int i = 1;
3206
3207           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3208             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3209
3210           for (; t1 && t1 != void_list_node;
3211                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3212             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3213               {
3214                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3215                                            TREE_PURPOSE (t2)))
3216                   {
3217                     if (pedantic)
3218                       {
3219                         cp_pedwarn ("default argument given for parameter %d of `%#D'",
3220                                     i, newdecl);
3221                         cp_pedwarn_at ("after previous specification in `%#D'",
3222                                        olddecl);
3223                       }
3224                   }
3225                 else
3226                   {
3227                     cp_error ("default argument given for parameter %d of `%#D'",
3228                               i, newdecl);
3229                     cp_error_at ("after previous specification in `%#D'",
3230                                  olddecl);
3231                   }
3232               }
3233
3234           if (DECL_THIS_INLINE (newdecl) && ! DECL_THIS_INLINE (olddecl)
3235               && TREE_ADDRESSABLE (olddecl) && warn_inline)
3236             {
3237               cp_warning ("`%#D' was used before it was declared inline",
3238                           newdecl);
3239               cp_warning_at ("previous non-inline declaration here",
3240                              olddecl);
3241             }
3242         }
3243     }
3244
3245   /* If new decl is `static' and an `extern' was seen previously,
3246      warn about it.  */
3247   warn_extern_redeclared_static (newdecl, olddecl);
3248
3249   /* We have committed to returning 1 at this point.  */
3250   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3251     {
3252       /* Now that functions must hold information normally held
3253          by field decls, there is extra work to do so that
3254          declaration information does not get destroyed during
3255          definition.  */
3256       if (DECL_VINDEX (olddecl))
3257         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3258       if (DECL_CONTEXT (olddecl))
3259         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3260       if (DECL_CLASS_CONTEXT (olddecl))
3261         DECL_CLASS_CONTEXT (newdecl) = DECL_CLASS_CONTEXT (olddecl);
3262       if (DECL_PENDING_INLINE_INFO (newdecl) == (struct pending_inline *)0)
3263         DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3264       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3265       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3266       DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3267       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3268       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3269       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3270       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3271
3272       /* Optionally warn about more than one declaration for the same
3273          name, but don't warn about a function declaration followed by a
3274          definition.  */
3275       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3276           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3277           /* Don't warn about extern decl followed by definition. */
3278           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3279           /* Don't warn about friends, let add_friend take care of it. */
3280           && ! DECL_FRIEND_P (newdecl))
3281         {
3282           cp_warning ("redundant redeclaration of `%D' in same scope", newdecl);
3283           cp_warning_at ("previous declaration of `%D'", olddecl);
3284         }
3285     }
3286
3287   /* Deal with C++: must preserve virtual function table size.  */
3288   if (TREE_CODE (olddecl) == TYPE_DECL)
3289     {
3290       register tree newtype = TREE_TYPE (newdecl);
3291       register tree oldtype = TREE_TYPE (olddecl);
3292
3293       if (newtype != error_mark_node && oldtype != error_mark_node
3294           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3295         {
3296           CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
3297           CLASSTYPE_FRIEND_CLASSES (newtype)
3298             = CLASSTYPE_FRIEND_CLASSES (oldtype);
3299         }
3300     }
3301
3302   /* Copy all the DECL_... slots specified in the new decl
3303      except for any that we copy here from the old type.  */
3304   DECL_MACHINE_ATTRIBUTES (newdecl)
3305     = merge_machine_decl_attributes (olddecl, newdecl);
3306
3307   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3308     {
3309       if (! duplicate_decls (DECL_TEMPLATE_RESULT (newdecl),
3310                              DECL_TEMPLATE_RESULT (olddecl)))
3311         cp_error ("invalid redeclaration of %D", newdecl);
3312       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3313       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3314         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3315                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3316
3317       return 1;
3318     }
3319
3320   if (types_match)
3321     {
3322       /* Automatically handles default parameters.  */
3323       tree oldtype = TREE_TYPE (olddecl);
3324       tree newtype;
3325
3326       /* Merge the data types specified in the two decls.  */
3327       newtype = common_type (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3328
3329       if (TREE_CODE (newdecl) == VAR_DECL)
3330         DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3331       /* Do this after calling `common_type' so that default
3332          parameters don't confuse us.  */
3333       else if (TREE_CODE (newdecl) == FUNCTION_DECL
3334           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3335               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3336         {
3337           TREE_TYPE (newdecl) = build_exception_variant (newtype,
3338                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3339           TREE_TYPE (olddecl) = build_exception_variant (newtype,
3340                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
3341
3342           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3343               && DECL_SOURCE_LINE (olddecl) != 0
3344               && flag_exceptions
3345               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3346                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3347             {
3348               cp_error ("declaration of `%F' throws different exceptions",
3349                         newdecl);
3350               cp_error_at ("than previous declaration `%F'", olddecl);
3351             }
3352         }
3353       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3354
3355       /* Lay the type out, unless already done.  */
3356       if (! same_type_p (newtype, oldtype)
3357           && TREE_TYPE (newdecl) != error_mark_node
3358           && !(processing_template_decl && uses_template_parms (newdecl)))
3359         layout_type (TREE_TYPE (newdecl));
3360
3361       if ((TREE_CODE (newdecl) == VAR_DECL
3362            || TREE_CODE (newdecl) == PARM_DECL
3363            || TREE_CODE (newdecl) == RESULT_DECL
3364            || TREE_CODE (newdecl) == FIELD_DECL
3365            || TREE_CODE (newdecl) == TYPE_DECL)
3366           && !(processing_template_decl && uses_template_parms (newdecl)))
3367         layout_decl (newdecl, 0);
3368
3369       /* Merge the type qualifiers.  */
3370       if (TREE_READONLY (newdecl))
3371         TREE_READONLY (olddecl) = 1;
3372       if (TREE_THIS_VOLATILE (newdecl))
3373         TREE_THIS_VOLATILE (olddecl) = 1;
3374
3375       /* Merge the initialization information.  */
3376       if (DECL_INITIAL (newdecl) == NULL_TREE
3377           && DECL_INITIAL (olddecl) != NULL_TREE)
3378         {
3379           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3380           DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
3381           DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
3382           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3383               && DECL_LANG_SPECIFIC (newdecl)
3384               && DECL_LANG_SPECIFIC (olddecl))
3385             DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3386         }
3387
3388       /* Merge the section attribute.
3389          We want to issue an error if the sections conflict but that must be
3390          done later in decl_attributes since we are called before attributes
3391          are assigned.  */
3392       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3393         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3394
3395       /* Keep the old rtl since we can safely use it.  */
3396       DECL_RTL (newdecl) = DECL_RTL (olddecl);
3397
3398       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3399         {
3400           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3401             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3402           DECL_NO_CHECK_MEMORY_USAGE (newdecl)
3403             |= DECL_NO_CHECK_MEMORY_USAGE (olddecl);
3404           DECL_NO_LIMIT_STACK (newdecl)
3405             |= DECL_NO_LIMIT_STACK (olddecl);
3406         }
3407     }
3408   /* If cannot merge, then use the new type and qualifiers,
3409      and don't preserve the old rtl.  */
3410   else
3411     {
3412       /* Clean out any memory we had of the old declaration.  */
3413       tree oldstatic = value_member (olddecl, static_aggregates);
3414       if (oldstatic)
3415         TREE_VALUE (oldstatic) = error_mark_node;
3416
3417       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3418       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3419       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3420       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3421     }
3422
3423   /* Merge the storage class information.  */
3424   DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
3425   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3426   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3427   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3428   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3429   if (! DECL_EXTERNAL (olddecl))
3430     DECL_EXTERNAL (newdecl) = 0;
3431
3432   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3433     {
3434       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3435       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3436       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3437       DECL_TEMPLATE_INSTANTIATED (newdecl)
3438         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3439       /* Don't really know how much of the language-specific
3440          values we should copy from old to new.  */
3441       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3442       DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
3443       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3444       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3445       olddecl_friend = DECL_FRIEND_P (olddecl);
3446
3447       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
3448       if (TREE_CODE (newdecl) == FUNCTION_DECL
3449           || DECL_FUNCTION_TEMPLATE_P (newdecl))
3450         DECL_BEFRIENDING_CLASSES (newdecl)
3451           = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3452                      DECL_BEFRIENDING_CLASSES (olddecl));
3453     }
3454
3455   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3456     {
3457       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3458           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3459         {
3460           /* If newdecl is not a specialization, then it is not a
3461              template-related function at all.  And that means that we
3462              shoud have exited above, returning 0.  */
3463           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3464                               0);
3465
3466           if (TREE_USED (olddecl))
3467             /* From [temp.expl.spec]:
3468
3469                If a template, a member template or the member of a class
3470                template is explicitly specialized then that
3471                specialization shall be declared before the first use of
3472                that specialization that would cause an implicit
3473                instantiation to take place, in every translation unit in
3474                which such a use occurs.  */
3475             cp_error ("explicit specialization of %D after first use",
3476                       olddecl);
3477
3478           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3479         }
3480       DECL_THIS_INLINE (newdecl) |= DECL_THIS_INLINE (olddecl);
3481
3482       /* If either decl says `inline', this fn is inline, unless its
3483          definition was passed already.  */
3484       if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3485         DECL_INLINE (olddecl) = 1;
3486       DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3487
3488       if (! types_match)
3489         {
3490           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3491           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3492           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3493         }
3494       if (! types_match || new_defines_function)
3495         {
3496           /* These need to be copied so that the names are available.
3497              Note that if the types do match, we'll preserve inline
3498              info and other bits, but if not, we won't.  */
3499           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3500           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3501         }
3502       if (new_defines_function)
3503         /* If defining a function declared with other language
3504            linkage, use the previously declared language linkage.  */
3505         DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3506       else if (types_match)
3507         {
3508           /* If redeclaring a builtin function, and not a definition,
3509              it stays built in.  */
3510           if (DECL_BUILT_IN (olddecl))
3511             {
3512               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3513               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3514               /* If we're keeping the built-in definition, keep the rtl,
3515                  regardless of declaration matches.  */
3516               DECL_RTL (newdecl) = DECL_RTL (olddecl);
3517             }
3518           else
3519             DECL_FRAME_SIZE (newdecl) = DECL_FRAME_SIZE (olddecl);
3520
3521           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3522           if ((DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl)))
3523             /* Previously saved insns go together with
3524                the function's previous definition.  */
3525             DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3526           /* Don't clear out the arguments if we're redefining a function.  */
3527           if (DECL_ARGUMENTS (olddecl))
3528             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3529         }
3530       if (DECL_LANG_SPECIFIC (olddecl))
3531         DECL_MAIN_VARIANT (newdecl) = DECL_MAIN_VARIANT (olddecl);
3532     }
3533
3534   if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3535     {
3536       NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3537     }
3538
3539   /* Now preserve various other info from the definition.  */
3540   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3541   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3542   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3543   DECL_ASSEMBLER_NAME (newdecl) = DECL_ASSEMBLER_NAME (olddecl);
3544
3545   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3546     {
3547       int function_size;
3548
3549       function_size = sizeof (struct tree_decl);
3550
3551       bcopy ((char *) newdecl + sizeof (struct tree_common),
3552              (char *) olddecl + sizeof (struct tree_common),
3553              function_size - sizeof (struct tree_common));
3554
3555       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3556         {
3557           /* If newdecl is a template instantiation, it is possible that
3558              the following sequence of events has occurred:
3559
3560              o A friend function was declared in a class template.  The
3561              class template was instantiated.
3562
3563              o The instantiation of the friend declaration was
3564              recorded on the instantiation list, and is newdecl.
3565
3566              o Later, however, instantiate_class_template called pushdecl
3567              on the newdecl to perform name injection.  But, pushdecl in
3568              turn called duplicate_decls when it discovered that another
3569              declaration of a global function with the same name already
3570              existed.
3571
3572              o Here, in duplicate_decls, we decided to clobber newdecl.
3573
3574              If we're going to do that, we'd better make sure that
3575              olddecl, and not newdecl, is on the list of
3576              instantiations so that if we try to do the instantiation
3577              again we won't get the clobbered declaration.  */
3578
3579           tree tmpl = DECL_TI_TEMPLATE (newdecl);
3580           tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3581
3582           for (; decls; decls = TREE_CHAIN (decls))
3583             if (TREE_VALUE (decls) == newdecl)
3584               TREE_VALUE (decls) = olddecl;
3585         }
3586     }
3587   else
3588     {
3589       bcopy ((char *) newdecl + sizeof (struct tree_common),
3590              (char *) olddecl + sizeof (struct tree_common),
3591              sizeof (struct tree_decl) - sizeof (struct tree_common)
3592              + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
3593     }
3594
3595   DECL_UID (olddecl) = olddecl_uid;
3596   if (olddecl_friend)
3597     DECL_FRIEND_P (olddecl) = 1;
3598
3599   /* NEWDECL contains the merged attribute lists.
3600      Update OLDDECL to be the same.  */
3601   DECL_MACHINE_ATTRIBUTES (olddecl) = DECL_MACHINE_ATTRIBUTES (newdecl);
3602
3603   return 1;
3604 }
3605
3606 /* Record a decl-node X as belonging to the current lexical scope.
3607    Check for errors (such as an incompatible declaration for the same
3608    name already seen in the same scope).
3609
3610    Returns either X or an old decl for the same name.
3611    If an old decl is returned, it may have been smashed
3612    to agree with what X says.  */
3613
3614 tree
3615 pushdecl (x)
3616      tree x;
3617 {
3618   register tree t;
3619   register tree name;
3620   int need_new_binding;
3621
3622   /* We shouldn't be calling pushdecl when we're generating RTL for a
3623      function that we already did semantic analysis on previously.  */
3624   my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3625                       19990913);
3626
3627   name = DECL_ASSEMBLER_NAME (x);
3628   need_new_binding = 1;
3629
3630   if (DECL_TEMPLATE_PARM_P (x))
3631     /* Template parameters have no context; they are not X::T even
3632        when declared within a class or namespace.  */
3633     ;
3634   else
3635     {
3636       if (current_function_decl && x != current_function_decl
3637           /* A local declaration for a function doesn't constitute
3638              nesting.  */
3639           && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3640           /* A local declaration for an `extern' variable is in the
3641              scoped of the current namespace, not the current
3642              function.  */
3643           && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3644           /* Don't change DECL_CONTEXT of virtual methods.  */
3645           && (TREE_CODE (x) != FUNCTION_DECL || !DECL_VIRTUAL_P (x))
3646           && !DECL_CONTEXT (x))
3647         DECL_CONTEXT (x) = current_function_decl;
3648       if (!DECL_CONTEXT (x))
3649         DECL_CONTEXT (x) = FROB_CONTEXT (current_namespace);
3650
3651       /* If this is the declaration for a namespace-scope function,
3652          but the declaration itself is in a local scope, mark the
3653          declaration.  */
3654       if (TREE_CODE (x) == FUNCTION_DECL
3655           && DECL_NAMESPACE_SCOPE_P (x)
3656           && current_function_decl
3657           && x != current_function_decl)
3658         DECL_LOCAL_FUNCTION_P (x) = 1;
3659     }
3660
3661   /* Type are looked up using the DECL_NAME, as that is what the rest of the
3662      compiler wants to use.  */
3663   if (TREE_CODE (x) == TYPE_DECL || TREE_CODE (x) == VAR_DECL
3664       || TREE_CODE (x) == NAMESPACE_DECL)
3665     name = DECL_NAME (x);
3666
3667   if (name)
3668     {
3669 #if 0
3670       /* Not needed...see below.  */
3671       char *file;
3672       int line;
3673 #endif
3674       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3675         name = TREE_OPERAND (name, 0);
3676
3677       /* Namespace-scoped variables are not found in the current level. */
3678       if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x))
3679         t = namespace_binding (name, DECL_CONTEXT (x));
3680       else
3681         t = lookup_name_current_level (name);
3682       if (t == error_mark_node)
3683         {
3684           /* error_mark_node is 0 for a while during initialization!  */
3685           t = NULL_TREE;
3686           cp_error_at ("`%#D' used prior to declaration", x);
3687         }
3688
3689       else if (t != NULL_TREE)
3690         {
3691 #if 0
3692           /* This is turned off until I have time to do it right (bpk).  */
3693           /* With the code below that uses it...  */
3694           file = DECL_SOURCE_FILE (t);
3695           line = DECL_SOURCE_LINE (t);
3696 #endif
3697           if (TREE_CODE (t) == PARM_DECL)
3698             {
3699               if (DECL_CONTEXT (t) == NULL_TREE)
3700                 fatal ("parse errors have confused me too much");
3701
3702               /* Check for duplicate params.  */
3703               if (duplicate_decls (x, t))
3704                 return t;
3705             }
3706           else if (((TREE_CODE (x) == FUNCTION_DECL && DECL_LANGUAGE (x) == lang_c)
3707                     || DECL_FUNCTION_TEMPLATE_P (x))
3708                    && is_overloaded_fn (t))
3709             /* Don't do anything just yet. */;
3710           else if (t == wchar_decl_node)
3711             {
3712               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3713                 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x));
3714
3715               /* Throw away the redeclaration.  */
3716               return t;
3717             }
3718           else if (TREE_CODE (t) != TREE_CODE (x))
3719             {
3720               if (duplicate_decls (x, t))
3721                 return t;
3722             }
3723           else if (duplicate_decls (x, t))
3724             {
3725 #if 0
3726               /* This is turned off until I have time to do it right (bpk).  */
3727
3728               /* Also warn if they did a prototype with `static' on it, but
3729                  then later left the `static' off.  */
3730               if (! TREE_PUBLIC (name) && TREE_PUBLIC (x))
3731                 {
3732                   if (DECL_LANG_SPECIFIC (t) && DECL_FRIEND_P (t))
3733                     return t;
3734
3735                   if (extra_warnings)
3736                     {
3737                       cp_warning ("`static' missing from declaration of `%D'",
3738                                   t);
3739                       warning_with_file_and_line (file, line,
3740                                                   "previous declaration of `%s'",
3741                                                   decl_as_string (t, 0));
3742                     }
3743
3744                   /* Now fix things so it'll do what they expect.  */
3745                   if (current_function_decl)
3746                     TREE_PUBLIC (current_function_decl) = 0;
3747                 }
3748               /* Due to interference in memory reclamation (X may be
3749                  obstack-deallocated at this point), we must guard against
3750                  one really special case.  [jason: This should be handled
3751                  by start_function]  */
3752               if (current_function_decl == x)
3753                 current_function_decl = t;
3754 #endif
3755               if (TREE_CODE (t) == TYPE_DECL)
3756                 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3757               else if (TREE_CODE (t) == FUNCTION_DECL)
3758                 check_default_args (t);
3759
3760               return t;
3761             }
3762           else if (DECL_MAIN_P (x))
3763             {
3764               /* A redeclaration of main, but not a duplicate of the
3765                  previous one.
3766
3767                  [basic.start.main]
3768
3769                  This function shall not be overloaded.  */
3770               cp_error_at ("invalid redeclaration of `%D'", t);
3771               cp_error ("as `%D'", x);
3772               /* We don't try to push this declaration since that
3773                  causes a crash.  */
3774               return x;
3775             }
3776         }
3777
3778       check_template_shadow (x);
3779
3780       /* If this is a function conjured up by the backend, massage it
3781          so it looks friendly.  */
3782       if (TREE_CODE (x) == FUNCTION_DECL
3783           && ! DECL_LANG_SPECIFIC (x))
3784         {
3785           retrofit_lang_decl (x);
3786           DECL_LANGUAGE (x) = lang_c;
3787         }
3788
3789       if (TREE_CODE (x) == FUNCTION_DECL && ! DECL_FUNCTION_MEMBER_P (x))
3790         {
3791           t = push_overloaded_decl (x, PUSH_LOCAL);
3792           if (t != x)
3793             return t;
3794           if (!namespace_bindings_p ())
3795             /* We do not need to create a binding for this name;
3796                push_overloaded_decl will have already done so if
3797                necessary.  */
3798             need_new_binding = 0;
3799         }
3800       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
3801         {
3802           t = push_overloaded_decl (x, PUSH_GLOBAL);
3803           if (t == x)
3804             add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
3805           return t;
3806         }
3807
3808       /* If declaring a type as a typedef, copy the type (unless we're
3809          at line 0), and install this TYPE_DECL as the new type's typedef
3810          name.  See the extensive comment in ../c-decl.c (pushdecl). */
3811       if (TREE_CODE (x) == TYPE_DECL)
3812         {
3813           tree type = TREE_TYPE (x);
3814           if (DECL_SOURCE_LINE (x) == 0)
3815             {
3816               if (TYPE_NAME (type) == 0)
3817                 TYPE_NAME (type) = x;
3818             }
3819           else if (type != error_mark_node && TYPE_NAME (type) != x
3820                    /* We don't want to copy the type when all we're
3821                       doing is making a TYPE_DECL for the purposes of
3822                       inlining.  */
3823                    && (!TYPE_NAME (type)
3824                        || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
3825             {
3826               DECL_ORIGINAL_TYPE (x) = type;
3827               type = build_type_copy (type);
3828               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
3829               TYPE_NAME (type) = x;
3830               TREE_TYPE (x) = type;
3831             }
3832
3833           if (type != error_mark_node
3834               && TYPE_NAME (type)
3835               && TYPE_IDENTIFIER (type))
3836             set_identifier_type_value_with_scope (DECL_NAME (x), type,
3837                                                   current_binding_level);
3838
3839         }
3840
3841       /* Multiple external decls of the same identifier ought to match.
3842
3843          We get warnings about inline functions where they are defined.
3844          We get warnings about other functions from push_overloaded_decl.
3845
3846          Avoid duplicate warnings where they are used.  */
3847       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
3848         {
3849           tree decl;
3850
3851           if (IDENTIFIER_NAMESPACE_VALUE (name) != NULL_TREE
3852               && (DECL_EXTERNAL (IDENTIFIER_NAMESPACE_VALUE (name))
3853                   || TREE_PUBLIC (IDENTIFIER_NAMESPACE_VALUE (name))))
3854             decl = IDENTIFIER_NAMESPACE_VALUE (name);
3855           else
3856             decl = NULL_TREE;
3857
3858           if (decl
3859               /* If different sort of thing, we already gave an error.  */
3860               && TREE_CODE (decl) == TREE_CODE (x)
3861               && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
3862             {
3863               cp_pedwarn ("type mismatch with previous external decl", x);
3864               cp_pedwarn_at ("previous external decl of `%#D'", decl);
3865             }
3866         }
3867
3868       /* This name is new in its binding level.
3869          Install the new declaration and return it.  */
3870       if (namespace_bindings_p ())
3871         {
3872           /* Install a global value.  */
3873
3874           /* If the first global decl has external linkage,
3875              warn if we later see static one.  */
3876           if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
3877             TREE_PUBLIC (name) = 1;
3878
3879           if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
3880                 && t != NULL_TREE)
3881               /* For an ordinary function, we create a binding from
3882                  the mangled name (i.e., NAME) to the DECL.  But, for
3883                  an `extern "C"' function, the mangled name and the
3884                  ordinary name are the same so we need not do this.  */
3885               && !(TREE_CODE (x) == FUNCTION_DECL &&
3886                    DECL_LANGUAGE (x) == lang_c))
3887             {
3888               if (TREE_CODE (x) == FUNCTION_DECL)
3889                 my_friendly_assert
3890                   ((IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE)
3891                   || (IDENTIFIER_GLOBAL_VALUE (name) == x), 378);
3892               SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
3893             }
3894
3895           /* Don't forget if the function was used via an implicit decl.  */
3896           if (IDENTIFIER_IMPLICIT_DECL (name)
3897               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
3898             TREE_USED (x) = 1;
3899
3900           /* Don't forget if its address was taken in that way.  */
3901           if (IDENTIFIER_IMPLICIT_DECL (name)
3902               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
3903             TREE_ADDRESSABLE (x) = 1;
3904
3905           /* Warn about mismatches against previous implicit decl.  */
3906           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
3907               /* If this real decl matches the implicit, don't complain.  */
3908               && ! (TREE_CODE (x) == FUNCTION_DECL
3909                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
3910             cp_warning
3911               ("`%D' was previously implicitly declared to return `int'", x);
3912
3913           /* If new decl is `static' and an `extern' was seen previously,
3914              warn about it.  */
3915           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
3916             warn_extern_redeclared_static (x, t);
3917         }
3918       else
3919         {
3920           /* Here to install a non-global value.  */
3921           tree oldlocal = IDENTIFIER_VALUE (name);
3922           tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
3923
3924           if (need_new_binding)
3925             {
3926               push_local_binding (name, x, 0);
3927               /* Because push_local_binding will hook X on to the
3928                  current_binding_level's name list, we don't want to
3929                  do that again below.  */
3930               need_new_binding = 0;
3931             }
3932
3933           /* If this is a TYPE_DECL, push it into the type value slot.  */
3934           if (TREE_CODE (x) == TYPE_DECL)
3935             set_identifier_type_value_with_scope (name, TREE_TYPE (x),
3936                                                   current_binding_level);
3937
3938           /* Clear out any TYPE_DECL shadowed by a namespace so that
3939              we won't think this is a type.  The C struct hack doesn't
3940              go through namespaces.  */
3941           if (TREE_CODE (x) == NAMESPACE_DECL)
3942             set_identifier_type_value_with_scope (name, NULL_TREE,
3943                                                   current_binding_level);
3944
3945           if (oldlocal)
3946             {
3947               tree d = oldlocal;
3948               while (oldlocal
3949                      && TREE_CODE (oldlocal) == VAR_DECL
3950                      && DECL_DEAD_FOR_LOCAL (oldlocal))
3951                 {
3952                   oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
3953                 }
3954               if (oldlocal == NULL_TREE)
3955                 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
3956             }
3957
3958           /* If this is an extern function declaration, see if we
3959              have a global definition or declaration for the function.  */
3960           if (oldlocal == NULL_TREE
3961               && DECL_EXTERNAL (x)
3962               && oldglobal != NULL_TREE
3963               && TREE_CODE (x) == FUNCTION_DECL
3964               && TREE_CODE (oldglobal) == FUNCTION_DECL)
3965             {
3966               /* We have one.  Their types must agree.  */
3967               if (decls_match (x, oldglobal))
3968                 /* OK */;
3969               else
3970                 {
3971                   cp_warning ("extern declaration of `%#D' doesn't match", x);
3972                   cp_warning_at ("global declaration `%#D'", oldglobal);
3973                 }
3974             }
3975           /* If we have a local external declaration,
3976              and no file-scope declaration has yet been seen,
3977              then if we later have a file-scope decl it must not be static.  */
3978           if (oldlocal == NULL_TREE
3979               && oldglobal == NULL_TREE
3980               && DECL_EXTERNAL (x)
3981               && TREE_PUBLIC (x))
3982             TREE_PUBLIC (name) = 1;
3983
3984           /* Warn if shadowing an argument at the top level of the body.  */
3985           if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
3986               /* Inline decls shadow nothing.  */
3987               && !DECL_FROM_INLINE (x)
3988               && TREE_CODE (oldlocal) == PARM_DECL
3989               /* Don't complain if it's from an enclosing function.  */
3990               && DECL_CONTEXT (oldlocal) == current_function_decl
3991               && TREE_CODE (x) != PARM_DECL)
3992             {
3993               /* Go to where the parms should be and see if we
3994                  find them there.  */
3995               struct binding_level *b = current_binding_level->level_chain;
3996
3997               if (cleanup_label)
3998                 b = b->level_chain;
3999
4000               /* ARM $8.3 */
4001               if (b->parm_flag == 1)
4002                 cp_error ("declaration of `%#D' shadows a parameter", name);
4003             }
4004
4005           /* Maybe warn if shadowing something else.  */
4006           if (warn_shadow && !DECL_EXTERNAL (x)
4007               /* Inline decls shadow nothing.  */
4008               && !DECL_FROM_INLINE (x)
4009               /* No shadow warnings for internally generated vars.  */
4010               && ! DECL_ARTIFICIAL (x)
4011               /* No shadow warnings for vars made for inlining.  */
4012               && ! DECL_FROM_INLINE (x))
4013             {
4014               if (oldlocal != NULL_TREE && TREE_CODE (oldlocal) == PARM_DECL)
4015                 warning ("declaration of `%s' shadows a parameter",
4016                         IDENTIFIER_POINTER (name));
4017               else if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4018                        && current_class_ptr
4019                        && !TREE_STATIC (name))
4020                 warning ("declaration of `%s' shadows a member of `this'",
4021                         IDENTIFIER_POINTER (name));
4022               else if (oldlocal != NULL_TREE)
4023                 warning ("declaration of `%s' shadows previous local",
4024                         IDENTIFIER_POINTER (name));
4025               else if (oldglobal != NULL_TREE)
4026                 /* XXX shadow warnings in outer-more namespaces */
4027                 warning ("declaration of `%s' shadows global declaration",
4028                         IDENTIFIER_POINTER (name));
4029             }
4030         }
4031
4032       if (TREE_CODE (x) == FUNCTION_DECL)
4033         check_default_args (x);
4034
4035       /* Keep count of variables in this level with incomplete type.  */
4036       if (TREE_CODE (x) == VAR_DECL
4037           && TREE_TYPE (x) != error_mark_node
4038           && ((TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
4039                && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
4040               /* RTTI TD entries are created while defining the type_info.  */
4041               || (TYPE_LANG_SPECIFIC (TREE_TYPE (x))
4042                   && TYPE_BEING_DEFINED (TREE_TYPE (x)))))
4043         {
4044           if (namespace_bindings_p ())
4045             namespace_scope_incomplete
4046               = tree_cons (NULL_TREE, x, namespace_scope_incomplete);
4047           else
4048             current_binding_level->incomplete
4049               = tree_cons (NULL_TREE, x, current_binding_level->incomplete);
4050         }
4051     }
4052
4053   if (need_new_binding)
4054     add_decl_to_level (x,
4055                        DECL_NAMESPACE_SCOPE_P (x)
4056                        ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4057                        : current_binding_level);
4058
4059   return x;
4060 }
4061
4062 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
4063    caller to set DECL_CONTEXT properly.  */
4064
4065 static tree
4066 pushdecl_with_scope (x, level)
4067      tree x;
4068      struct binding_level *level;
4069 {
4070   register struct binding_level *b;
4071   tree function_decl = current_function_decl;
4072
4073   current_function_decl = NULL_TREE;
4074   if (level->parm_flag == 2)
4075     {
4076       b = class_binding_level;
4077       class_binding_level = level;
4078       pushdecl_class_level (x);
4079       class_binding_level = b;
4080     }
4081   else
4082     {
4083       b = current_binding_level;
4084       current_binding_level = level;
4085       x = pushdecl (x);
4086       current_binding_level = b;
4087     }
4088   current_function_decl = function_decl;
4089   return x;
4090 }
4091
4092 /* Like pushdecl, only it places X in the current namespace,
4093    if appropriate.  */
4094
4095 tree
4096 pushdecl_namespace_level (x)
4097      tree x;
4098 {
4099   register struct binding_level *b = current_binding_level;
4100   register tree t;
4101
4102   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4103
4104   /* Now, the type_shadowed stack may screw us.  Munge it so it does
4105      what we want.  */
4106   if (TREE_CODE (x) == TYPE_DECL)
4107     {
4108       tree name = DECL_NAME (x);
4109       tree newval;
4110       tree *ptr = (tree *)0;
4111       for (; b != global_binding_level; b = b->level_chain)
4112         {
4113           tree shadowed = b->type_shadowed;
4114           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4115             if (TREE_PURPOSE (shadowed) == name)
4116               {
4117                 ptr = &TREE_VALUE (shadowed);
4118                 /* Can't break out of the loop here because sometimes
4119                    a binding level will have duplicate bindings for
4120                    PT names.  It's gross, but I haven't time to fix it.  */
4121               }
4122         }
4123       newval = TREE_TYPE (x);
4124       if (ptr == (tree *)0)
4125         {
4126           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
4127              up here if this is changed to an assertion.  --KR  */
4128           SET_IDENTIFIER_TYPE_VALUE (name, newval);
4129         }
4130       else
4131         {
4132           *ptr = newval;
4133         }
4134     }
4135   return t;
4136 }
4137
4138 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4139    if appropriate.  */
4140
4141 tree
4142 pushdecl_top_level (x)
4143      tree x;
4144 {
4145   push_to_top_level ();
4146   x = pushdecl_namespace_level (x);
4147   pop_from_top_level ();
4148   return x;
4149 }
4150
4151 /* Make the declaration of X appear in CLASS scope.  */
4152
4153 void
4154 pushdecl_class_level (x)
4155      tree x;
4156 {
4157   /* Don't use DECL_ASSEMBLER_NAME here!  Everything that looks in class
4158      scope looks for the pre-mangled name.  */
4159   register tree name;
4160
4161   if (TREE_CODE (x) == OVERLOAD)
4162     x = OVL_CURRENT (x);
4163   name = DECL_NAME (x);
4164
4165   if (name)
4166     {
4167       push_class_level_binding (name, x);
4168       if (TREE_CODE (x) == TYPE_DECL)
4169         set_identifier_type_value (name, TREE_TYPE (x));
4170     }
4171   else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4172     {
4173       tree f;
4174
4175       for (f = TYPE_FIELDS (TREE_TYPE (x));
4176            f;
4177            f = TREE_CHAIN (f))
4178         pushdecl_class_level (f);
4179     }
4180 }
4181
4182 /* Enter DECL into the symbol table, if that's appropriate.  Returns
4183    DECL, or a modified version thereof.  */
4184
4185 tree
4186 maybe_push_decl (decl)
4187      tree decl;
4188 {
4189   tree type = TREE_TYPE (decl);
4190
4191   /* Add this decl to the current binding level, but not if it comes
4192      from another scope, e.g. a static member variable.  TEM may equal
4193      DECL or it may be a previous decl of the same name.  */
4194   if (decl == error_mark_node
4195       || (TREE_CODE (decl) != PARM_DECL
4196           && DECL_CONTEXT (decl) != NULL_TREE
4197           /* Definitions of namespace members outside their namespace are
4198              possible. */
4199           && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4200       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4201       || TREE_CODE (type) == UNKNOWN_TYPE
4202       /* The declaration of a template specialization does not affect
4203          the functions available for overload resolution, so we do not
4204          call pushdecl.  */
4205       || (TREE_CODE (decl) == FUNCTION_DECL
4206           && DECL_TEMPLATE_SPECIALIZATION (decl)))
4207     return decl;
4208   else
4209     return pushdecl (decl);
4210 }
4211
4212 #if 0
4213 /* This function is used to push the mangled decls for nested types into
4214    the appropriate scope.  Previously pushdecl_top_level was used, but that
4215    is incorrect for members of local classes.  */
4216
4217 void
4218 pushdecl_nonclass_level (x)
4219      tree x;
4220 {
4221   struct binding_level *b = current_binding_level;
4222
4223   my_friendly_assert (b->parm_flag != 2, 180);
4224
4225 #if 0
4226   /* Get out of template binding levels */
4227   while (b->pseudo_global)
4228     b = b->level_chain;
4229 #endif
4230
4231   pushdecl_with_scope (x, b);
4232 }
4233 #endif
4234
4235 /* Make the declaration(s) of X appear in CLASS scope
4236    under the name NAME.  */
4237
4238 void
4239 push_class_level_binding (name, x)
4240      tree name;
4241      tree x;
4242 {
4243   tree binding;
4244   /* The class_binding_level will be NULL if x is a template
4245      parameter name in a member template.  */
4246   if (!class_binding_level)
4247     return;
4248
4249   /* Make sure that this new member does not have the same name
4250      as a template parameter.  */
4251   if (TYPE_BEING_DEFINED (current_class_type))
4252     check_template_shadow (x);
4253
4254   /* If this declaration shadows a declaration from an enclosing
4255      class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4256      we leave this class.  Record the shadowed declaration here.  */
4257   binding = IDENTIFIER_BINDING (name);
4258   if (binding
4259       && ((TREE_CODE (x) == OVERLOAD
4260            && BINDING_VALUE (binding)
4261            && is_overloaded_fn (BINDING_VALUE (binding)))
4262           || INHERITED_VALUE_BINDING_P (binding)))
4263     {
4264       tree shadow;
4265       tree old_decl;
4266
4267       /* If the old binding was from a base class, and was for a tag
4268          name, slide it over to make room for the new binding.  The
4269          old binding is still visible if explicitly qualified with a
4270          class-key.  */
4271       if (INHERITED_VALUE_BINDING_P (binding)
4272           && BINDING_VALUE (binding)
4273           && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4274           && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4275           && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4276         {
4277           old_decl = BINDING_TYPE (binding);
4278           BINDING_TYPE (binding) = BINDING_VALUE (binding);
4279           BINDING_VALUE (binding) = NULL_TREE;
4280           INHERITED_VALUE_BINDING_P (binding) = 0;
4281         }
4282       else
4283         old_decl = BINDING_VALUE (binding);
4284
4285       /* There was already a binding for X containing fewer
4286          functions than are named in X.  Find the previous
4287          declaration of X on the class-shadowed list, and update it.  */
4288       for (shadow = class_binding_level->class_shadowed;
4289            shadow;
4290            shadow = TREE_CHAIN (shadow))
4291         if (TREE_PURPOSE (shadow) == name
4292             && TREE_TYPE (shadow) == old_decl)
4293           {
4294             BINDING_VALUE (binding) = x;
4295             INHERITED_VALUE_BINDING_P (binding) = 0;
4296             TREE_TYPE (shadow) = x;
4297             return;
4298           }
4299     }
4300
4301   /* If we didn't replace an existing binding, put the binding on the
4302      stack of bindings for the identifier, and update
4303      IDENTIFIER_CLASS_VALUE.  */
4304   if (push_class_binding (name, x))
4305     {
4306       class_binding_level->class_shadowed
4307         = tree_cons (name, IDENTIFIER_CLASS_VALUE (name),
4308                      class_binding_level->class_shadowed);
4309       /* Record the value we are binding NAME to so that we can know
4310          what to pop later.  */
4311       TREE_TYPE (class_binding_level->class_shadowed) = x;
4312     }
4313 }
4314
4315 /* Insert another USING_DECL into the current binding level,
4316    returning this declaration. If this is a redeclaration,
4317    do nothing and return NULL_TREE.  */
4318
4319 tree
4320 push_using_decl (scope, name)
4321      tree scope;
4322      tree name;
4323 {
4324   tree decl;
4325
4326   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4327   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4328   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4329     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4330       break;
4331   if (decl)
4332     return NULL_TREE;
4333   decl = build_lang_decl (USING_DECL, name, void_type_node);
4334   DECL_INITIAL (decl) = scope;
4335   TREE_CHAIN (decl) = current_binding_level->usings;
4336   current_binding_level->usings = decl;
4337   return decl;
4338 }
4339
4340 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4341    changed (i.e. there was already a directive), or the fresh
4342    TREE_LIST otherwise.  */
4343
4344 tree
4345 push_using_directive (used)
4346      tree used;
4347 {
4348   tree ud = current_binding_level->using_directives;
4349   tree iter, ancestor;
4350
4351   /* Check if we already have this. */
4352   if (purpose_member (used, ud) != NULL_TREE)
4353     return NULL_TREE;
4354
4355   /* Recursively add all namespaces used. */
4356   for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4357     push_using_directive (TREE_PURPOSE (iter));
4358
4359   ancestor = namespace_ancestor (current_decl_namespace (), used);
4360   ud = current_binding_level->using_directives;
4361   ud = tree_cons (used, ancestor, ud);
4362   current_binding_level->using_directives = ud;
4363   return ud;
4364 }
4365
4366 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4367    other definitions already in place.  We get around this by making
4368    the value of the identifier point to a list of all the things that
4369    want to be referenced by that name.  It is then up to the users of
4370    that name to decide what to do with that list.
4371
4372    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its DECL_RESULT
4373    slot.  It is dealt with the same way.
4374
4375    FLAGS is a bitwise-or of the following values:
4376      PUSH_LOCAL: Bind DECL in the current scope, rather than at
4377                  namespace scope.
4378      PUSH_USING: DECL is being pushed as the result of a using
4379                  declaration.
4380
4381    The value returned may be a previous declaration if we guessed wrong
4382    about what language DECL should belong to (C or C++).  Otherwise,
4383    it's always DECL (and never something that's not a _DECL).  */
4384
4385 tree
4386 push_overloaded_decl (decl, flags)
4387      tree decl;
4388      int flags;
4389 {
4390   tree name = DECL_NAME (decl);
4391   tree old;
4392   tree new_binding;
4393   int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4394
4395   if (doing_global)
4396     old = namespace_binding (name, DECL_CONTEXT (decl));
4397   else
4398     old = lookup_name_current_level (name);
4399
4400   if (old)
4401     {
4402       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4403         {
4404           tree t = TREE_TYPE (old);
4405           if (IS_AGGR_TYPE (t) && warn_shadow
4406               && (! DECL_IN_SYSTEM_HEADER (decl)
4407                   || ! DECL_IN_SYSTEM_HEADER (old)))
4408             cp_warning ("`%#D' hides constructor for `%#T'", decl, t);
4409           old = NULL_TREE;
4410         }
4411       else if (is_overloaded_fn (old))
4412         {
4413           tree tmp;
4414
4415           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4416             {
4417               tree fn = OVL_CURRENT (tmp);
4418
4419               if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4420                   && !(flags & PUSH_USING)
4421                   && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4422                                 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4423                 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4424                           decl, fn);
4425
4426               if (duplicate_decls (decl, fn))
4427                 return fn;
4428             }
4429         }
4430       else
4431         {
4432           cp_error_at ("previous non-function declaration `%#D'", old);
4433           cp_error ("conflicts with function declaration `%#D'", decl);
4434           return decl;
4435         }
4436     }
4437
4438   if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4439     {
4440       if (old && TREE_CODE (old) != OVERLOAD)
4441         new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4442       else
4443         new_binding = ovl_cons (decl, old);
4444       if (flags & PUSH_USING)
4445         OVL_USED (new_binding) = 1;
4446     }
4447   else
4448     /* NAME is not ambiguous.  */
4449     new_binding = decl;
4450
4451   if (doing_global)
4452     set_namespace_binding (name, current_namespace, new_binding);
4453   else
4454     {
4455       /* We only create an OVERLOAD if there was a previous binding at
4456          this level, or if decl is a template. In the former case, we
4457          need to remove the old binding and replace it with the new
4458          binding.  We must also run through the NAMES on the binding
4459          level where the name was bound to update the chain.  */
4460
4461       if (TREE_CODE (new_binding) == OVERLOAD && old)
4462         {
4463           tree *d;
4464
4465           for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4466                *d;
4467                d = &TREE_CHAIN (*d))
4468             if (*d == old
4469                 || (TREE_CODE (*d) == TREE_LIST
4470                     && TREE_VALUE (*d) == old))
4471               {
4472                 if (TREE_CODE (*d) == TREE_LIST)
4473                   /* Just replace the old binding with the new.  */
4474                   TREE_VALUE (*d) = new_binding;
4475                 else
4476                   /* Build a TREE_LIST to wrap the OVERLOAD.  */
4477                   *d = tree_cons (NULL_TREE, new_binding,
4478                                   TREE_CHAIN (*d));
4479
4480                 /* And update the CPLUS_BINDING node.  */
4481                 BINDING_VALUE (IDENTIFIER_BINDING (name))
4482                   = new_binding;
4483                 return decl;
4484               }
4485
4486           /* We should always find a previous binding in this case.  */
4487           my_friendly_abort (0);
4488         }
4489
4490       /* Install the new binding.  */
4491       push_local_binding (name, new_binding, flags);
4492     }
4493
4494   return decl;
4495 }
4496 \f
4497 /* Generate an implicit declaration for identifier FUNCTIONID
4498    as a function of type int ().  Print a warning if appropriate.  */
4499
4500 tree
4501 implicitly_declare (functionid)
4502      tree functionid;
4503 {
4504   register tree decl;
4505
4506   /* We used to reuse an old implicit decl here,
4507      but this loses with inline functions because it can clobber
4508      the saved decl chains.  */
4509   decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4510
4511   DECL_EXTERNAL (decl) = 1;
4512   TREE_PUBLIC (decl) = 1;
4513
4514   /* ANSI standard says implicit declarations are in the innermost block.
4515      So we record the decl in the standard fashion.  */
4516   pushdecl (decl);
4517   rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
4518
4519   if (warn_implicit
4520       /* Only one warning per identifier.  */
4521       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4522     {
4523       cp_pedwarn ("implicit declaration of function `%#D'", decl);
4524     }
4525
4526   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4527
4528   return decl;
4529 }
4530
4531 /* Return zero if the declaration NEWDECL is valid
4532    when the declaration OLDDECL (assumed to be for the same name)
4533    has already been seen.
4534    Otherwise return an error message format string with a %s
4535    where the identifier should go.  */
4536
4537 static const char *
4538 redeclaration_error_message (newdecl, olddecl)
4539      tree newdecl, olddecl;
4540 {
4541   if (TREE_CODE (newdecl) == TYPE_DECL)
4542     {
4543       /* Because C++ can put things into name space for free,
4544          constructs like "typedef struct foo { ... } foo"
4545          would look like an erroneous redeclaration.  */
4546       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4547         return 0;
4548       else
4549         return "redefinition of `%#D'";
4550     }
4551   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4552     {
4553       /* If this is a pure function, its olddecl will actually be
4554          the original initialization to `0' (which we force to call
4555          abort()).  Don't complain about redefinition in this case.  */
4556       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4557         return 0;
4558
4559       /* If both functions come from different namespaces, this is not
4560          a redeclaration - this is a conflict with a used function. */
4561       if (DECL_NAMESPACE_SCOPE_P (olddecl)
4562           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4563         return "`%D' conflicts with used function";
4564
4565       /* We'll complain about linkage mismatches in
4566          warn_extern_redeclared_static.  */
4567
4568       /* Defining the same name twice is no good.  */
4569       if (DECL_INITIAL (olddecl) != NULL_TREE
4570           && DECL_INITIAL (newdecl) != NULL_TREE)
4571         {
4572           if (DECL_NAME (olddecl) == NULL_TREE)
4573             return "`%#D' not declared in class";
4574           else
4575             return "redefinition of `%#D'";
4576         }
4577       return 0;
4578     }
4579   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4580     {
4581       if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4582            && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4583            && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4584           || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4585               && TYPE_SIZE (TREE_TYPE (newdecl))
4586               && TYPE_SIZE (TREE_TYPE (olddecl))))
4587         return "redefinition of `%#D'";
4588       return 0;
4589     }
4590   else if (toplevel_bindings_p ())
4591     {
4592       /* Objects declared at top level:  */
4593       /* If at least one is a reference, it's ok.  */
4594       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4595         return 0;
4596       /* Reject two definitions.  */
4597       return "redefinition of `%#D'";
4598     }
4599   else
4600     {
4601       /* Objects declared with block scope:  */
4602       /* Reject two definitions, and reject a definition
4603          together with an external reference.  */
4604       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4605         return "redeclaration of `%#D'";
4606       return 0;
4607     }
4608 }
4609 \f
4610 /* Create a new label, named ID.  */
4611
4612 static tree
4613 make_label_decl (id, local_p)
4614      tree id;
4615      int local_p;
4616 {
4617   tree decl;
4618
4619   decl = build_decl (LABEL_DECL, id, void_type_node);
4620   if (expanding_p)
4621     /* Make sure every label has an rtx.  */
4622     label_rtx (decl);
4623
4624   DECL_CONTEXT (decl) = current_function_decl;
4625   DECL_MODE (decl) = VOIDmode;
4626   C_DECLARED_LABEL_FLAG (decl) = local_p;
4627
4628   /* Say where one reference is to the label, for the sake of the
4629      error if it is not defined.  */
4630   DECL_SOURCE_LINE (decl) = lineno;
4631   DECL_SOURCE_FILE (decl) = input_filename;
4632
4633   /* Record the fact that this identifier is bound to this label.  */
4634   SET_IDENTIFIER_LABEL_VALUE (id, decl);
4635
4636   /* Record this label on the list of used labels so that we can check
4637      at the end of the function to see whether or not the label was
4638      actually defined.  */
4639   if ((named_label_uses == NULL || named_label_uses->label_decl != decl)
4640       && (named_label_uses == NULL
4641           || named_label_uses->names_in_scope != current_binding_level->names
4642           || named_label_uses->label_decl != decl))
4643     {
4644       struct named_label_list *new_ent;
4645       new_ent
4646         = (struct named_label_list*)oballoc (sizeof (struct named_label_list));
4647       new_ent->label_decl = decl;
4648       new_ent->names_in_scope = current_binding_level->names;
4649       new_ent->binding_level = current_binding_level;
4650       new_ent->lineno_o_goto = lineno;
4651       new_ent->filename_o_goto = input_filename;
4652       new_ent->next = named_label_uses;
4653       named_label_uses = new_ent;
4654     }
4655
4656   return decl;
4657 }
4658
4659 /* Look for a label named ID in the current function.  If one cannot
4660    be found, create one.  (We keep track of used, but undefined,
4661    labels, and complain about them at the end of a function.)  */
4662
4663 tree
4664 lookup_label (id)
4665      tree id;
4666 {
4667   tree decl;
4668
4669   /* You can't use labels at global scope.  */
4670   if (current_function_decl == NULL_TREE)
4671     {
4672       error ("label `%s' referenced outside of any function",
4673              IDENTIFIER_POINTER (id));
4674       return NULL_TREE;
4675     }
4676
4677   /* See if we've already got this label.  */
4678   decl = IDENTIFIER_LABEL_VALUE (id);
4679   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4680     return decl;
4681
4682   /* Record this label on the list of labels used in this function.
4683      We do this before calling make_label_decl so that we get the
4684      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
4685   named_labels = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4686                             named_labels);
4687   /* We need a new label.  */
4688   decl = make_label_decl (id, /*local_p=*/0);
4689   /* Now fill in the information we didn't have before.  */
4690   TREE_VALUE (named_labels) = decl;
4691
4692   return decl;
4693 }
4694
4695 /* Declare a local label named ID.  */
4696
4697 tree
4698 declare_local_label (id)
4699      tree id;
4700 {
4701   tree decl;
4702
4703   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4704      this scope we can restore the old value of
4705      IDENTIFIER_TYPE_VALUE.  */
4706   current_binding_level->shadowed_labels
4707     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4708                  current_binding_level->shadowed_labels);
4709   /* Look for the label.  */
4710   decl = make_label_decl (id, /*local_p=*/1);
4711   /* Now fill in the information we didn't have before.  */
4712   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4713
4714   return decl;
4715 }
4716
4717 /* Define a label, specifying the location in the source file.
4718    Return the LABEL_DECL node for the label, if the definition is valid.
4719    Otherwise return 0.  */
4720
4721 tree
4722 define_label (filename, line, name)
4723      char *filename;
4724      int line;
4725      tree name;
4726 {
4727   tree decl = lookup_label (name);
4728
4729   /* After labels, make any new cleanups go into their
4730      own new (temporary) binding contour.  */
4731   current_binding_level->more_cleanups_ok = 0;
4732
4733   if (name == get_identifier ("wchar_t"))
4734     cp_pedwarn ("label named wchar_t");
4735
4736   if (DECL_INITIAL (decl) != NULL_TREE)
4737     {
4738       cp_error ("duplicate label `%D'", decl);
4739       return 0;
4740     }
4741   else
4742     {
4743       struct named_label_list *uses, *prev;
4744       int identified = 0;
4745       int saw_eh = 0;
4746
4747       /* Mark label as having been defined.  */
4748       DECL_INITIAL (decl) = error_mark_node;
4749       /* Say where in the source.  */
4750       DECL_SOURCE_FILE (decl) = filename;
4751       DECL_SOURCE_LINE (decl) = line;
4752
4753       prev = NULL;
4754       uses = named_label_uses;
4755       while (uses != NULL)
4756         if (uses->label_decl == decl)
4757           {
4758             struct binding_level *b = current_binding_level;
4759             while (b)
4760               {
4761                 tree new_decls = b->names;
4762                 tree old_decls = (b == uses->binding_level)
4763                                   ? uses->names_in_scope : NULL_TREE;
4764                 while (new_decls != old_decls)
4765                   {
4766                     if (TREE_CODE (new_decls) == VAR_DECL
4767                         /* Don't complain about crossing initialization
4768                            of internal entities.  They can't be accessed,
4769                            and they should be cleaned up
4770                            by the time we get to the label.  */
4771                         && ! DECL_ARTIFICIAL (new_decls)
4772                         && !(DECL_INITIAL (new_decls) == NULL_TREE
4773                              && pod_type_p (TREE_TYPE (new_decls))))
4774                       {
4775                         /* This is really only important if we're crossing
4776                            an initialization.  The POD stuff is just
4777                            pedantry; why should it matter if the class
4778                            contains a field of pointer to member type?  */
4779                         int problem = (DECL_INITIAL (new_decls)
4780                                        || (TYPE_NEEDS_CONSTRUCTING
4781                                            (TREE_TYPE (new_decls))));
4782
4783                         if (! identified)
4784                           {
4785                             if (problem)
4786                               {
4787                                 cp_error ("jump to label `%D'", decl);
4788                                 error_with_file_and_line
4789                                   (uses->filename_o_goto,
4790                                    uses->lineno_o_goto, "  from here");
4791                               }
4792                             else
4793                               {
4794                                 cp_pedwarn ("jump to label `%D'", decl);
4795                                 pedwarn_with_file_and_line
4796                                   (uses->filename_o_goto,
4797                                    uses->lineno_o_goto, "  from here");
4798                               }
4799                             identified = 1;
4800                           }
4801
4802                         if (problem)
4803                           cp_error_at ("  crosses initialization of `%#D'",
4804                                        new_decls);
4805                         else
4806                           cp_pedwarn_at ("  enters scope of non-POD `%#D'",
4807                                          new_decls);
4808                       }
4809                     new_decls = TREE_CHAIN (new_decls);
4810                   }
4811                 if (b == uses->binding_level)
4812                   break;
4813                 if (b->eh_region && ! saw_eh)
4814                   {
4815                     if (! identified)
4816                       {
4817                         cp_error ("jump to label `%D'", decl);
4818                         error_with_file_and_line
4819                           (uses->filename_o_goto,
4820                            uses->lineno_o_goto, "  from here");
4821                         identified = 1;
4822                       }
4823                     error ("  enters exception handling block");
4824                     saw_eh = 1;
4825                   }
4826                 b = b->level_chain;
4827               }
4828
4829             if (prev != NULL)
4830               prev->next = uses->next;
4831             else
4832               named_label_uses = uses->next;
4833
4834             uses = uses->next;
4835           }
4836         else
4837           {
4838             prev = uses;
4839             uses = uses->next;
4840           }
4841       current_function_return_value = NULL_TREE;
4842       return decl;
4843     }
4844 }
4845
4846 struct cp_switch
4847 {
4848   struct binding_level *level;
4849   struct cp_switch *next;
4850 };
4851
4852 static struct cp_switch *switch_stack;
4853
4854 void
4855 push_switch ()
4856 {
4857   struct cp_switch *p
4858     = (struct cp_switch *) oballoc (sizeof (struct cp_switch));
4859   p->level = current_binding_level;
4860   p->next = switch_stack;
4861   switch_stack = p;
4862 }
4863
4864 void
4865 pop_switch ()
4866 {
4867   switch_stack = switch_stack->next;
4868 }
4869
4870 /* Note that we've seen a definition of a case label, and complain if this
4871    is a bad place for one.  */
4872
4873 void
4874 define_case_label ()
4875 {
4876   tree cleanup = last_cleanup_this_contour ();
4877   struct binding_level *b = current_binding_level;
4878   int identified = 0;
4879
4880   if (! switch_stack)
4881     /* Don't crash; we'll complain in do_case.  */
4882     return;
4883
4884   if (cleanup)
4885     {
4886       static int explained = 0;
4887       cp_warning_at ("destructor needed for `%#D'", TREE_PURPOSE (cleanup));
4888       warning ("where case label appears here");
4889       if (!explained)
4890         {
4891           warning ("(enclose actions of previous case statements requiring");
4892           warning ("destructors in their own binding contours.)");
4893           explained = 1;
4894         }
4895     }
4896
4897   for (; b && b != switch_stack->level; b = b->level_chain)
4898     {
4899       tree new_decls = b->names;
4900       for (; new_decls; new_decls = TREE_CHAIN (new_decls))
4901         {
4902           if (TREE_CODE (new_decls) == VAR_DECL
4903               /* Don't complain about crossing initialization
4904                  of internal entities.  They can't be accessed,
4905                  and they should be cleaned up
4906                  by the time we get to the label.  */
4907               && ! DECL_ARTIFICIAL (new_decls)
4908               && ((DECL_INITIAL (new_decls) != NULL_TREE
4909                    && DECL_INITIAL (new_decls) != error_mark_node)
4910                   || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (new_decls))))
4911             {
4912               if (! identified)
4913                 error ("jump to case label");
4914               identified = 1;
4915               cp_error_at ("  crosses initialization of `%#D'",
4916                            new_decls);
4917             }
4918         }
4919     }
4920
4921   /* After labels, make any new cleanups go into their
4922      own new (temporary) binding contour.  */
4923
4924   current_binding_level->more_cleanups_ok = 0;
4925   current_function_return_value = NULL_TREE;
4926 }
4927 \f
4928 /* Return the list of declarations of the current level.
4929    Note that this list is in reverse order unless/until
4930    you nreverse it; and when you do nreverse it, you must
4931    store the result back using `storedecls' or you will lose.  */
4932
4933 tree
4934 getdecls ()
4935 {
4936   return current_binding_level->names;
4937 }
4938
4939 /* Return the list of type-tags (for structs, etc) of the current level.  */
4940
4941 tree
4942 gettags ()
4943 {
4944   return current_binding_level->tags;
4945 }
4946
4947 /* Store the list of declarations of the current level.
4948    This is done for the parameter declarations of a function being defined,
4949    after they are modified in the light of any missing parameters.  */
4950
4951 static void
4952 storedecls (decls)
4953      tree decls;
4954 {
4955   current_binding_level->names = decls;
4956 }
4957
4958 /* Similarly, store the list of tags of the current level.  */
4959
4960 void
4961 storetags (tags)
4962      tree tags;
4963 {
4964   current_binding_level->tags = tags;
4965 }
4966 \f
4967 /* Given NAME, an IDENTIFIER_NODE,
4968    return the structure (or union or enum) definition for that name.
4969    Searches binding levels from BINDING_LEVEL up to the global level.
4970    If THISLEVEL_ONLY is nonzero, searches only the specified context
4971    (but skips any tag-transparent contexts to find one that is
4972    meaningful for tags).
4973    FORM says which kind of type the caller wants;
4974    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
4975    If the wrong kind of type is found, and it's not a template, an error is
4976    reported.  */
4977
4978 static tree
4979 lookup_tag (form, name, binding_level, thislevel_only)
4980      enum tree_code form;
4981      tree name;
4982      struct binding_level *binding_level;
4983      int thislevel_only;
4984 {
4985   register struct binding_level *level;
4986   /* Non-zero if, we should look past a pseudo-global level, even if
4987      THISLEVEL_ONLY.  */
4988   int allow_pseudo_global = 1;
4989
4990   for (level = binding_level; level; level = level->level_chain)
4991     {
4992       register tree tail;
4993       if (ANON_AGGRNAME_P (name))
4994         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
4995           {
4996             /* There's no need for error checking here, because
4997                anon names are unique throughout the compilation.  */
4998             if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
4999               return TREE_VALUE (tail);
5000           }
5001       else if (level->namespace_p)
5002         /* Do namespace lookup. */
5003         for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
5004           {
5005             tree old = binding_for_name (name, tail);
5006
5007             /* If we just skipped past a pseudo global level, even
5008                though THISLEVEL_ONLY, and we find a template class
5009                declaration, then we use the _TYPE node for the
5010                template.  See the example below.  */
5011             if (thislevel_only && !allow_pseudo_global
5012                 && old && BINDING_VALUE (old)
5013                 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
5014               old = TREE_TYPE (BINDING_VALUE (old));
5015             else
5016               old = BINDING_TYPE (old);
5017
5018             /* If it has an original type, it is a typedef, and we
5019                should not return it.  */
5020             if (old && DECL_ORIGINAL_TYPE (TYPE_NAME (old)))
5021               old = NULL_TREE;
5022             if (old && TREE_CODE (old) != form
5023                 && !(form != ENUMERAL_TYPE && TREE_CODE (old) == TEMPLATE_DECL))
5024               {
5025                 cp_error ("`%#D' redeclared as %C", old, form);
5026                 return NULL_TREE;
5027               }
5028             if (old)
5029               return old;
5030             if (thislevel_only || tail == global_namespace)
5031               return NULL_TREE;
5032           }
5033       else
5034         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5035           {
5036             if (TREE_PURPOSE (tail) == name)
5037               {
5038                 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5039                 /* Should tighten this up; it'll probably permit
5040                    UNION_TYPE and a struct template, for example.  */
5041                 if (code != form
5042                     && !(form != ENUMERAL_TYPE && code == TEMPLATE_DECL))
5043                   {
5044                     /* Definition isn't the kind we were looking for.  */
5045                     cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
5046                               form);
5047                     return NULL_TREE;
5048                   }
5049                 return TREE_VALUE (tail);
5050               }
5051           }
5052       if (thislevel_only && ! level->tag_transparent)
5053         {
5054           if (level->pseudo_global && allow_pseudo_global)
5055             {
5056               /* We must deal with cases like this:
5057
5058                    template <class T> struct S;
5059                    template <class T> struct S {};
5060
5061                  When looking up `S', for the second declaration, we
5062                  would like to find the first declaration.  But, we
5063                  are in the pseudo-global level created for the
5064                  template parameters, rather than the (surrounding)
5065                  namespace level.  Thus, we keep going one more level,
5066                  even though THISLEVEL_ONLY is non-zero.  */
5067               allow_pseudo_global = 0;
5068               continue;
5069             }
5070           else
5071             return NULL_TREE;
5072         }
5073     }
5074   return NULL_TREE;
5075 }
5076
5077 #if 0
5078 void
5079 set_current_level_tags_transparency (tags_transparent)
5080      int tags_transparent;
5081 {
5082   current_binding_level->tag_transparent = tags_transparent;
5083 }
5084 #endif
5085
5086 /* Given a type, find the tag that was defined for it and return the tag name.
5087    Otherwise return 0.  However, the value can never be 0
5088    in the cases in which this is used.
5089
5090    C++: If NAME is non-zero, this is the new name to install.  This is
5091    done when replacing anonymous tags with real tag names.  */
5092
5093 static tree
5094 lookup_tag_reverse (type, name)
5095      tree type;
5096      tree name;
5097 {
5098   register struct binding_level *level;
5099
5100   for (level = current_binding_level; level; level = level->level_chain)
5101     {
5102       register tree tail;
5103       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5104         {
5105           if (TREE_VALUE (tail) == type)
5106             {
5107               if (name)
5108                 TREE_PURPOSE (tail) = name;
5109               return TREE_PURPOSE (tail);
5110             }
5111         }
5112     }
5113   return NULL_TREE;
5114 }
5115 \f
5116 /* Look up NAME in the NAMESPACE.  */
5117
5118 tree
5119 lookup_namespace_name (namespace, name)
5120      tree namespace, name;
5121 {
5122   tree val;
5123   tree template_id = NULL_TREE;
5124
5125   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5126
5127   if (TREE_CODE (name) == NAMESPACE_DECL)
5128     /* This happens for A::B<int> when B is a namespace. */
5129     return name;
5130   else if (TREE_CODE (name) == TEMPLATE_DECL)
5131     {
5132       /* This happens for A::B where B is a template, and there are no
5133          template arguments.  */
5134       cp_error ("invalid use of `%D'", name);
5135       return error_mark_node;
5136     }
5137
5138   namespace = ORIGINAL_NAMESPACE (namespace);
5139
5140   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5141     {
5142       template_id = name;
5143       name = TREE_OPERAND (name, 0);
5144       if (TREE_CODE (name) == OVERLOAD)
5145         name = DECL_NAME (OVL_CURRENT (name));
5146       else if (TREE_CODE_CLASS (TREE_CODE (name)) == 'd')
5147         name = DECL_NAME (name);
5148     }
5149
5150   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5151
5152   val = make_node (CPLUS_BINDING);
5153   if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5154     return error_mark_node;
5155
5156   if (BINDING_VALUE (val))
5157     {
5158       val = BINDING_VALUE (val);
5159
5160       if (template_id)
5161         {
5162           if (DECL_CLASS_TEMPLATE_P (val))
5163             val = lookup_template_class (val,
5164                                          TREE_OPERAND (template_id, 1),
5165                                          /*in_decl=*/NULL_TREE,
5166                                          /*context=*/NULL_TREE,
5167                                          /*entering_scope=*/0);
5168           else if (DECL_FUNCTION_TEMPLATE_P (val)
5169                    || TREE_CODE (val) == OVERLOAD)
5170             val = lookup_template_function (val,
5171                                             TREE_OPERAND (template_id, 1));
5172           else
5173             {
5174               cp_error ("`%D::%D' is not a template",
5175                         namespace, name);
5176               return error_mark_node;
5177             }
5178         }
5179
5180       /* If we have a single function from a using decl, pull it out.  */
5181       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5182         val = OVL_FUNCTION (val);
5183       return val;
5184     }
5185
5186   cp_error ("`%D' undeclared in namespace `%D'", name, namespace);
5187   return error_mark_node;
5188 }
5189
5190 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
5191
5192 static unsigned long
5193 typename_hash (k)
5194      hash_table_key k;
5195 {
5196   unsigned long hash;
5197   tree t;
5198
5199   t = (tree) k;
5200   hash = (((unsigned long) TYPE_CONTEXT (t))
5201           ^ ((unsigned long) DECL_NAME (TYPE_NAME (t))));
5202
5203   return hash;
5204 }
5205
5206 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
5207
5208 static boolean
5209 typename_compare (k1, k2)
5210      hash_table_key k1;
5211      hash_table_key k2;
5212 {
5213   tree t1;
5214   tree t2;
5215   tree d1;
5216   tree d2;
5217
5218   t1 = (tree) k1;
5219   t2 = (tree) k2;
5220   d1 = TYPE_NAME (t1);
5221   d2 = TYPE_NAME (t2);
5222
5223   return (DECL_NAME (d1) == DECL_NAME (d2)
5224           && same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))
5225           && ((TREE_TYPE (t1) != NULL_TREE)
5226               == (TREE_TYPE (t2) != NULL_TREE))
5227           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5228           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5229 }
5230
5231 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
5232    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
5233    is non-NULL, this type is being created by the implicit typename
5234    extension, and BASE_TYPE is a type named `t' in some base class of
5235    `T' which depends on template parameters.
5236
5237    Returns the new TYPENAME_TYPE.  */
5238
5239 tree
5240 build_typename_type (context, name, fullname, base_type)
5241      tree context;
5242      tree name;
5243      tree fullname;
5244      tree base_type;
5245 {
5246   tree t;
5247   tree d;
5248   struct hash_entry* e;
5249
5250   static struct hash_table ht;
5251
5252   if (!ht.table)
5253     {
5254       static struct hash_table *h = &ht;
5255       if (!hash_table_init (&ht, &hash_newfunc, &typename_hash,
5256                             &typename_compare))
5257         fatal ("virtual memory exhausted");
5258       ggc_add_tree_hash_table_root (&h, 1);
5259     }
5260
5261   /* Build the TYPENAME_TYPE.  */
5262   t = make_aggr_type (TYPENAME_TYPE);
5263   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5264   TYPENAME_TYPE_FULLNAME (t) = fullname;
5265   TREE_TYPE (t) = base_type;
5266
5267   /* Build the corresponding TYPE_DECL.  */
5268   d = build_decl (TYPE_DECL, name, t);
5269   TYPE_NAME (TREE_TYPE (d)) = d;
5270   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5271   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5272   DECL_ARTIFICIAL (d) = 1;
5273
5274   /* See if we already have this type.  */
5275   e = hash_lookup (&ht, t, /*create=*/false, /*copy=*/0);
5276   if (e)
5277     t = (tree) e->key;
5278   else
5279     /* Insert the type into the table.  */
5280     hash_lookup (&ht, t, /*create=*/true, /*copy=*/0);
5281
5282   return t;
5283 }
5284
5285 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
5286    unless an error occurs, in which case error_mark_node is returned.
5287    If COMPLAIN zero, don't complain about any errors that occur.  */
5288
5289 tree
5290 make_typename_type (context, name, complain)
5291      tree context, name;
5292      int complain;
5293 {
5294   tree fullname;
5295
5296   if (TREE_CODE_CLASS (TREE_CODE (name)) == 't')
5297     {
5298       if (!(TYPE_LANG_SPECIFIC (name)
5299             && (CLASSTYPE_IS_TEMPLATE (name)
5300                 || CLASSTYPE_USE_TEMPLATE (name))))
5301         name = TYPE_IDENTIFIER (name);
5302       else
5303         /* Create a TEMPLATE_ID_EXPR for the type.  */
5304         name = build_nt (TEMPLATE_ID_EXPR,
5305                          CLASSTYPE_TI_TEMPLATE (name),
5306                          CLASSTYPE_TI_ARGS (name));
5307     }
5308   else if (TREE_CODE (name) == TYPE_DECL)
5309     name = DECL_NAME (name);
5310
5311   fullname = name;
5312
5313   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5314     {
5315       name = TREE_OPERAND (name, 0);
5316       if (TREE_CODE (name) == TEMPLATE_DECL)
5317         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5318     }
5319   if (TREE_CODE (name) != IDENTIFIER_NODE)
5320     my_friendly_abort (2000);
5321
5322   if (TREE_CODE (context) == NAMESPACE_DECL)
5323     {
5324       /* We can get here from typename_sub0 in the explicit_template_type
5325          expansion.  Just fail.  */
5326       if (complain)
5327         cp_error ("no class template named `%#T' in `%#T'",
5328                   name, context);
5329       return error_mark_node;
5330     }
5331
5332   if (! uses_template_parms (context)
5333       || currently_open_class (context))
5334     {
5335       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5336         {
5337           tree tmpl = NULL_TREE;
5338           if (IS_AGGR_TYPE (context))
5339             tmpl = lookup_field (context, name, 0, 0);
5340           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5341             {
5342               if (complain)
5343                 cp_error ("no class template named `%#T' in `%#T'",
5344                           name, context);
5345               return error_mark_node;
5346             }
5347
5348           return lookup_template_class (tmpl,
5349                                         TREE_OPERAND (fullname, 1),
5350                                         NULL_TREE, context,
5351                                         /*entering_scope=*/0);
5352         }
5353       else
5354         {
5355           tree t;
5356
5357           if (!IS_AGGR_TYPE (context))
5358             {
5359               if (complain)
5360                 cp_error ("no type named `%#T' in `%#T'", name, context);
5361               return error_mark_node;
5362             }
5363
5364           t = lookup_field (context, name, 0, 1);
5365           if (t)
5366             return TREE_TYPE (t);
5367         }
5368     }
5369
5370   /* If the CONTEXT is not a template type, then either the field is
5371      there now or its never going to be.  */
5372   if (!uses_template_parms (context))
5373     {
5374       if (complain)
5375         cp_error ("no type named `%#T' in `%#T'", name, context);
5376       return error_mark_node;
5377     }
5378
5379
5380   return build_typename_type (context, name, fullname,  NULL_TREE);
5381 }
5382
5383 /* Select the right _DECL from multiple choices. */
5384
5385 static tree
5386 select_decl (binding, flags)
5387      tree binding;
5388      int flags;
5389 {
5390   tree val;
5391   val = BINDING_VALUE (binding);
5392   if (LOOKUP_NAMESPACES_ONLY (flags))
5393     {
5394       /* We are not interested in types. */
5395       if (val && TREE_CODE (val) == NAMESPACE_DECL)
5396         return val;
5397       return NULL_TREE;
5398     }
5399
5400   /* If we could have a type and
5401      we have nothing or we need a type and have none.  */
5402   if (BINDING_TYPE (binding)
5403       && (!val || ((flags & LOOKUP_PREFER_TYPES)
5404                    && TREE_CODE (val) != TYPE_DECL)))
5405     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5406   /* Don't return non-types if we really prefer types. */
5407   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
5408            && (TREE_CODE (val) != TEMPLATE_DECL
5409                || !DECL_CLASS_TEMPLATE_P (val)))
5410     val = NULL_TREE;
5411
5412   return val;
5413 }
5414
5415 /* Unscoped lookup of a global: iterate over current namespaces,
5416    considering using-directives.  If SPACESP is non-NULL, store a list
5417    of the namespaces we've considered in it.  */
5418
5419 tree
5420 unqualified_namespace_lookup (name, flags, spacesp)
5421      tree name;
5422      int flags;
5423      tree *spacesp;
5424 {
5425   tree b = make_node (CPLUS_BINDING);
5426   tree initial = current_decl_namespace();
5427   tree scope = initial;
5428   tree siter;
5429   struct binding_level *level;
5430   tree val = NULL_TREE;
5431
5432   if (spacesp)
5433     *spacesp = NULL_TREE;
5434
5435   for (; !val; scope = CP_DECL_CONTEXT (scope))
5436     {
5437       if (spacesp)
5438         *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5439       val = binding_for_name (name, scope);
5440
5441       /* Initialize binding for this context. */
5442       BINDING_VALUE (b) = BINDING_VALUE (val);
5443       BINDING_TYPE (b) = BINDING_TYPE (val);
5444
5445       /* Add all _DECLs seen through local using-directives. */
5446       for (level = current_binding_level;
5447            !level->namespace_p;
5448            level = level->level_chain)
5449         if (!lookup_using_namespace (name, b, level->using_directives,
5450                                      scope, flags, spacesp))
5451           /* Give up because of error. */
5452           return error_mark_node;
5453
5454       /* Add all _DECLs seen through global using-directives. */
5455       /* XXX local and global using lists should work equally. */
5456       siter = initial;
5457       while (1)
5458         {
5459           if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5460                                        scope, flags, spacesp))
5461             /* Give up because of error. */
5462             return error_mark_node;
5463           if (siter == scope) break;
5464           siter = CP_DECL_CONTEXT (siter);
5465         }
5466
5467       val = select_decl (b, flags);
5468       if (scope == global_namespace)
5469         break;
5470     }
5471   return val;
5472 }
5473
5474 /* Combine prefer_type and namespaces_only into flags.  */
5475
5476 static int
5477 lookup_flags (prefer_type, namespaces_only)
5478   int prefer_type, namespaces_only;
5479 {
5480   if (namespaces_only)
5481     return LOOKUP_PREFER_NAMESPACES;
5482   if (prefer_type > 1)
5483     return LOOKUP_PREFER_TYPES;
5484   if (prefer_type > 0)
5485     return LOOKUP_PREFER_BOTH;
5486   return 0;
5487 }
5488
5489 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5490    ignore it or not.  Subroutine of lookup_name_real.  */
5491
5492 static tree
5493 qualify_lookup (val, flags)
5494      tree val;
5495      int flags;
5496 {
5497   if (val == NULL_TREE)
5498     return val;
5499   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5500     return val;
5501   if ((flags & LOOKUP_PREFER_TYPES)
5502       && (TREE_CODE (val) == TYPE_DECL
5503           || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5504               && DECL_CLASS_TEMPLATE_P (val))))
5505     return val;
5506   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5507     return NULL_TREE;
5508   return val;
5509 }
5510
5511 /* Any other BINDING overrides an implicit TYPENAME.  Warn about
5512    that.  */
5513
5514 static void
5515 warn_about_implicit_typename_lookup (typename, binding)
5516      tree typename;
5517      tree binding;
5518 {
5519   tree subtype = TREE_TYPE (TREE_TYPE (typename));
5520   tree name = DECL_NAME (typename);
5521
5522   if (! (TREE_CODE (binding) == TEMPLATE_DECL
5523          && CLASSTYPE_TEMPLATE_INFO (subtype)
5524          && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
5525       && ! (TREE_CODE (binding) == TYPE_DECL
5526             && same_type_p (TREE_TYPE (binding), subtype)))
5527     {
5528       cp_warning ("lookup of `%D' finds `%#D'",
5529                   name, binding);
5530       cp_warning ("  instead of `%D' from dependent base class",
5531                   typename);
5532       cp_warning ("  (use `typename %T::%D' if that's what you meant)",
5533                   constructor_name (current_class_type), name);
5534     }
5535 }
5536
5537 /* Look up NAME in the current binding level and its superiors in the
5538    namespace of variables, functions and typedefs.  Return a ..._DECL
5539    node of some kind representing its definition if there is only one
5540    such declaration, or return a TREE_LIST with all the overloaded
5541    definitions if there are many, or return 0 if it is undefined.
5542
5543    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5544    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5545    If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5546    Otherwise we prefer non-TYPE_DECLs.
5547
5548    If NONCLASS is non-zero, we don't look for the NAME in class scope,
5549    using IDENTIFIER_CLASS_VALUE.  */
5550
5551 static tree
5552 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
5553      tree name;
5554      int prefer_type, nonclass, namespaces_only;
5555 {
5556   tree t;
5557   tree val = NULL_TREE;
5558   int yylex = 0;
5559   tree from_obj = NULL_TREE;
5560   int flags;
5561   int val_is_implicit_typename = 0;
5562
5563   /* Hack: copy flag set by parser, if set. */
5564   if (only_namespace_names)
5565     namespaces_only = 1;
5566
5567   if (prefer_type == -2)
5568     {
5569       extern int looking_for_typename;
5570       tree type = NULL_TREE;
5571
5572       yylex = 1;
5573       prefer_type = looking_for_typename;
5574
5575       flags = lookup_flags (prefer_type, namespaces_only);
5576       /* If the next thing is '<', class templates are types. */
5577       if (looking_for_template)
5578         flags |= LOOKUP_TEMPLATES_EXPECTED;
5579
5580       /* std:: becomes :: for now.  */
5581       if (got_scope == std_node)
5582         got_scope = void_type_node;
5583
5584       if (got_scope)
5585         type = got_scope;
5586       else if (got_object != error_mark_node)
5587         type = got_object;
5588
5589       if (type)
5590         {
5591           if (type == error_mark_node)
5592             return error_mark_node;
5593           if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
5594             type = TREE_TYPE (type);
5595
5596           if (TYPE_P (type))
5597             type = complete_type (type);
5598
5599           if (TREE_CODE (type) == VOID_TYPE)
5600             type = global_namespace;
5601           if (TREE_CODE (type) == NAMESPACE_DECL)
5602             {
5603               val = make_node (CPLUS_BINDING);
5604               flags |= LOOKUP_COMPLAIN;
5605               if (!qualified_lookup_using_namespace (name, type, val, flags))
5606                 return NULL_TREE;
5607               val = select_decl (val, flags);
5608             }
5609           else if (! IS_AGGR_TYPE (type)
5610                    || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5611                    || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM
5612                    || TREE_CODE (type) == TYPENAME_TYPE)
5613             /* Someone else will give an error about this if needed.  */
5614             val = NULL_TREE;
5615           else if (type == current_class_type)
5616             val = IDENTIFIER_CLASS_VALUE (name);
5617           else
5618             {
5619               val = lookup_member (type, name, 0, prefer_type);
5620               type_access_control (type, val);
5621             }
5622         }
5623       else
5624         val = NULL_TREE;
5625
5626       if (got_scope)
5627         goto done;
5628       else if (got_object && val)
5629         from_obj = val;
5630     }
5631   else
5632     {
5633       flags = lookup_flags (prefer_type, namespaces_only);
5634       /* If we're not parsing, we need to complain. */
5635       flags |= LOOKUP_COMPLAIN;
5636     }
5637
5638   /* First, look in non-namespace scopes.  */
5639
5640   if (current_class_type == NULL_TREE)
5641     nonclass = 1;
5642
5643   for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
5644     {
5645       tree binding;
5646
5647       if (!LOCAL_BINDING_P (t) && nonclass)
5648         /* We're not looking for class-scoped bindings, so keep going.  */
5649         continue;
5650
5651       /* If this is the kind of thing we're looking for, we're done.  */
5652       if (qualify_lookup (BINDING_VALUE (t), flags))
5653         binding = BINDING_VALUE (t);
5654       else if ((flags & LOOKUP_PREFER_TYPES)
5655                && qualify_lookup (BINDING_TYPE (t), flags))
5656         binding = BINDING_TYPE (t);
5657       else
5658         binding = NULL_TREE;
5659
5660       /* Handle access control on types from enclosing or base classes.  */
5661       if (binding && ! yylex
5662           && BINDING_LEVEL (t) && BINDING_LEVEL (t)->parm_flag == 2)
5663         type_access_control (BINDING_LEVEL (t)->this_class, binding);
5664
5665       if (binding
5666           && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
5667         {
5668           if (val_is_implicit_typename && !yylex)
5669             warn_about_implicit_typename_lookup (val, binding);
5670           val = binding;
5671           val_is_implicit_typename
5672             = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
5673           if (!val_is_implicit_typename)
5674             break;
5675         }
5676     }
5677
5678   /* Now lookup in namespace scopes.  */
5679   if (!val || val_is_implicit_typename)
5680     {
5681       t = unqualified_namespace_lookup (name, flags, 0);
5682       if (t)
5683         {
5684           if (val_is_implicit_typename && !yylex)
5685             warn_about_implicit_typename_lookup (val, t);
5686           val = t;
5687         }
5688     }
5689
5690  done:
5691   if (val)
5692     {
5693       /* This should only warn about types used in qualified-ids.  */
5694       if (from_obj && from_obj != val)
5695         {
5696           if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
5697               && TREE_CODE (val) == TYPE_DECL
5698               && TREE_TYPE (from_obj) != TREE_TYPE (val))
5699             {
5700               cp_pedwarn ("lookup of `%D' in the scope of `%#T' (`%#T')",
5701                           name, got_object, TREE_TYPE (from_obj));
5702               cp_pedwarn ("  does not match lookup in the current scope (`%#T')",
5703                           TREE_TYPE (val));
5704             }
5705
5706           /* We don't change val to from_obj if got_object depends on
5707              template parms because that breaks implicit typename for
5708              destructor calls.  */
5709           if (! uses_template_parms (got_object))
5710             val = from_obj;
5711         }
5712
5713       /* If we have a single function from a using decl, pull it out.  */
5714       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5715         val = OVL_FUNCTION (val);
5716     }
5717   else if (from_obj)
5718     val = from_obj;
5719
5720   return val;
5721 }
5722
5723 tree
5724 lookup_name_nonclass (name)
5725      tree name;
5726 {
5727   return lookup_name_real (name, 0, 1, 0);
5728 }
5729
5730 tree
5731 lookup_function_nonclass (name, args)
5732      tree name;
5733      tree args;
5734 {
5735   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
5736 }
5737
5738 tree
5739 lookup_name_namespace_only (name)
5740      tree name;
5741 {
5742   /* type-or-namespace, nonclass, namespace_only */
5743   return lookup_name_real (name, 1, 1, 1);
5744 }
5745
5746 tree
5747 lookup_name (name, prefer_type)
5748      tree name;
5749      int prefer_type;
5750 {
5751   return lookup_name_real (name, prefer_type, 0, 0);
5752 }
5753
5754 /* Similar to `lookup_name' but look only in the innermost non-class
5755    binding level.  */
5756
5757 tree
5758 lookup_name_current_level (name)
5759      tree name;
5760 {
5761   struct binding_level *b;
5762   tree t = NULL_TREE;
5763
5764   b = current_binding_level;
5765   while (b->parm_flag == 2)
5766     b = b->level_chain;
5767
5768   if (b->namespace_p)
5769     {
5770       t = IDENTIFIER_NAMESPACE_VALUE (name);
5771
5772       /* extern "C" function() */
5773       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
5774         t = TREE_VALUE (t);
5775     }
5776   else if (IDENTIFIER_BINDING (name)
5777            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
5778     {
5779       while (1)
5780         {
5781           if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
5782             return IDENTIFIER_VALUE (name);
5783
5784           if (b->keep == 2)
5785             b = b->level_chain;
5786           else
5787             break;
5788         }
5789     }
5790
5791   return t;
5792 }
5793
5794 /* Like lookup_name_current_level, but for types.  */
5795
5796 tree
5797 lookup_type_current_level (name)
5798      tree name;
5799 {
5800   register tree t = NULL_TREE;
5801
5802   my_friendly_assert (! current_binding_level->namespace_p, 980716);
5803
5804   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
5805       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
5806     {
5807       struct binding_level *b = current_binding_level;
5808       while (1)
5809         {
5810           if (purpose_member (name, b->type_shadowed))
5811             return REAL_IDENTIFIER_TYPE_VALUE (name);
5812           if (b->keep == 2)
5813             b = b->level_chain;
5814           else
5815             break;
5816         }
5817     }
5818
5819   return t;
5820 }
5821
5822 void
5823 begin_only_namespace_names ()
5824 {
5825   only_namespace_names = 1;
5826 }
5827
5828 void
5829 end_only_namespace_names ()
5830 {
5831   only_namespace_names = 0;
5832 }
5833 \f
5834 /* Arrange for the user to get a source line number, even when the
5835    compiler is going down in flames, so that she at least has a
5836    chance of working around problems in the compiler.  We used to
5837    call error(), but that let the segmentation fault continue
5838    through; now, it's much more passive by asking them to send the
5839    maintainers mail about the problem.  */
5840
5841 static void
5842 signal_catch (sig)
5843      int sig ATTRIBUTE_UNUSED;
5844 {
5845   signal (SIGSEGV, SIG_DFL);
5846 #ifdef SIGIOT
5847   signal (SIGIOT, SIG_DFL);
5848 #endif
5849 #ifdef SIGILL
5850   signal (SIGILL, SIG_DFL);
5851 #endif
5852 #ifdef SIGABRT
5853   signal (SIGABRT, SIG_DFL);
5854 #endif
5855 #ifdef SIGBUS
5856   signal (SIGBUS, SIG_DFL);
5857 #endif
5858   my_friendly_abort (0);
5859 }
5860
5861 /* Push the declarations of builtin types into the namespace.
5862    RID_INDEX, if < RID_MAX is the index of the builtin type
5863    in the array RID_POINTERS.  NAME is the name used when looking
5864    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
5865
5866 static void
5867 record_builtin_type (rid_index, name, type)
5868      enum rid rid_index;
5869      const char *name;
5870      tree type;
5871 {
5872   tree rname = NULL_TREE, tname = NULL_TREE;
5873   tree tdecl = NULL_TREE;
5874
5875   if ((int) rid_index < (int) RID_MAX)
5876     rname = ridpointers[(int) rid_index];
5877   if (name)
5878     tname = get_identifier (name);
5879
5880   TYPE_BUILT_IN (type) = 1;
5881
5882   if (tname)
5883     {
5884       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
5885       set_identifier_type_value (tname, NULL_TREE);
5886       if ((int) rid_index < (int) RID_MAX)
5887         /* Built-in types live in the global namespace. */
5888         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
5889     }
5890   if (rname != NULL_TREE)
5891     {
5892       if (tname != NULL_TREE)
5893         {
5894           set_identifier_type_value (rname, NULL_TREE);
5895           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
5896         }
5897       else
5898         {
5899           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
5900           set_identifier_type_value (rname, NULL_TREE);
5901         }
5902     }
5903 }
5904
5905 /* Record one of the standard Java types.
5906  * Declare it as having the given NAME.
5907  * If SIZE > 0, it is the size of one of the integral types;
5908  * otherwise it is the negative of the size of one of the other types.  */
5909
5910 static tree
5911 record_builtin_java_type (name, size)
5912      const char *name;
5913      int size;
5914 {
5915   tree type, decl;
5916   if (size > 0)
5917     type = make_signed_type (size);
5918   else if (size > -32)
5919     { /* "__java_char" or ""__java_boolean". */
5920       type = make_unsigned_type (-size);
5921       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
5922     }
5923   else
5924     { /* "__java_float" or ""__java_double". */
5925       type = make_node (REAL_TYPE);
5926       TYPE_PRECISION (type) = - size;
5927       layout_type (type);
5928     }
5929   record_builtin_type (RID_MAX, name, type);
5930   decl = TYPE_NAME (type);
5931
5932   /* Suppress generate debug symbol entries for these types,
5933      since for normal C++ they are just clutter.
5934      However, push_lang_context undoes this if extern "Java" is seen. */
5935   DECL_IGNORED_P (decl) = 1;
5936
5937   TYPE_FOR_JAVA (type) = 1;
5938   return type;
5939 }
5940
5941 /* Push a type into the namespace so that the back-ends ignore it. */
5942
5943 static void
5944 record_unknown_type (type, name)
5945      tree type;
5946      const char *name;
5947 {
5948   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
5949   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
5950   DECL_IGNORED_P (decl) = 1;
5951   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
5952   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
5953   TYPE_ALIGN (type) = 1;
5954   TYPE_MODE (type) = TYPE_MODE (void_type_node);
5955 }
5956
5957 /* Push overloaded decl, in global scope, with one argument so it
5958    can be used as a callback from define_function.  */
5959
5960 static void
5961 push_overloaded_decl_1 (x)
5962      tree x;
5963 {
5964   pushdecl (x);
5965 }
5966
5967 inline tree
5968 auto_function (name, type)
5969      tree name, type;
5970 {
5971   return define_function
5972     (IDENTIFIER_POINTER (name), type, push_overloaded_decl_1,
5973      IDENTIFIER_POINTER (build_decl_overload (name, TYPE_ARG_TYPES (type),
5974                                               0)));
5975 }
5976
5977 /* Create the predefined scalar types of C,
5978    and some nodes representing standard constants (0, 1, (void *)0).
5979    Initialize the global binding level.
5980    Make definitions for built-in primitive functions.  */
5981
5982 void
5983 init_decl_processing ()
5984 {
5985   tree fields[20];
5986   int wchar_type_size;
5987   tree array_domain_type;
5988
5989   /* Check to see that the user did not specify an invalid combination
5990      of command-line options.  */
5991   if (flag_new_abi && !flag_vtable_thunks)
5992     fatal ("the new ABI requires vtable thunks");
5993
5994   /* Have to make these distinct before we try using them.  */
5995   lang_name_cplusplus = get_identifier ("C++");
5996   lang_name_c = get_identifier ("C");
5997   lang_name_java = get_identifier ("Java");
5998
5999   /* Let the back-end now how to save and restore language-specific
6000      per-function globals.  */
6001   init_lang_status = &push_cp_function_context;
6002   free_lang_status = &pop_cp_function_context;
6003   mark_lang_status = &mark_cp_function_context;
6004
6005   cp_parse_init ();
6006   init_decl2 ();
6007   init_pt ();
6008
6009   /* Create the global variables.  */
6010   push_to_top_level ();
6011
6012   /* Enter the global namespace. */
6013   my_friendly_assert (global_namespace == NULL_TREE, 375);
6014   push_namespace (get_identifier ("::"));
6015   global_namespace = current_namespace;
6016   current_lang_name = NULL_TREE;
6017
6018   /* Adjust various flags based on command-line settings.  */
6019   if (flag_strict_prototype == 2)
6020     flag_strict_prototype = pedantic;
6021   if (! flag_permissive && ! pedantic)
6022     flag_pedantic_errors = 1;
6023   if (!flag_no_inline)
6024     flag_inline_trees = 1;
6025
6026   strict_prototypes_lang_c = flag_strict_prototype;
6027
6028   /* Initially, C.  */
6029   current_lang_name = lang_name_c;
6030
6031   current_function_decl = NULL_TREE;
6032   current_binding_level = NULL_BINDING_LEVEL;
6033   free_binding_level = NULL_BINDING_LEVEL;
6034
6035   /* Because most segmentation signals can be traced back into user
6036      code, catch them and at least give the user a chance of working
6037      around compiler bugs.  */
6038   signal (SIGSEGV, signal_catch);
6039
6040   /* We will also catch aborts in the back-end through signal_catch and
6041      give the user a chance to see where the error might be, and to defeat
6042      aborts in the back-end when there have been errors previously in their
6043      code.  */
6044 #ifdef SIGIOT
6045   signal (SIGIOT, signal_catch);
6046 #endif
6047 #ifdef SIGILL
6048   signal (SIGILL, signal_catch);
6049 #endif
6050 #ifdef SIGABRT
6051   signal (SIGABRT, signal_catch);
6052 #endif
6053 #ifdef SIGBUS
6054   signal (SIGBUS, signal_catch);
6055 #endif
6056
6057   build_common_tree_nodes (flag_signed_char);
6058
6059   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6060   TREE_TYPE (error_mark_list) = error_mark_node;
6061
6062   /* Make the binding_level structure for global names.  */
6063   pushlevel (0);
6064   global_binding_level = current_binding_level;
6065   /* The global level is the namespace level of ::.  */
6066   NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6067   declare_namespace_level ();
6068
6069   this_identifier = get_identifier (THIS_NAME);
6070   in_charge_identifier = get_identifier (IN_CHARGE_NAME);
6071   ctor_identifier = get_identifier (CTOR_NAME);
6072   dtor_identifier = get_identifier (DTOR_NAME);
6073   pfn_identifier = get_identifier (VTABLE_PFN_NAME);
6074   index_identifier = get_identifier (VTABLE_INDEX_NAME);
6075   delta_identifier = get_identifier (VTABLE_DELTA_NAME);
6076   delta2_identifier = get_identifier (VTABLE_DELTA2_NAME);
6077   pfn_or_delta2_identifier = get_identifier ("__pfn_or_delta2");
6078
6079   /* Define `int' and `char' first so that dbx will output them first.  */
6080   record_builtin_type (RID_INT, NULL_PTR, integer_type_node);
6081   record_builtin_type (RID_CHAR, "char", char_type_node);
6082
6083   /* `signed' is the same as `int' */
6084   record_builtin_type (RID_SIGNED, NULL_PTR, integer_type_node);
6085   record_builtin_type (RID_LONG, "long int", long_integer_type_node);
6086   record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
6087   record_builtin_type (RID_MAX, "long unsigned int", long_unsigned_type_node);
6088   record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
6089   record_builtin_type (RID_MAX, "long long int", long_long_integer_type_node);
6090   record_builtin_type (RID_MAX, "long long unsigned int",
6091                        long_long_unsigned_type_node);
6092   record_builtin_type (RID_MAX, "long long unsigned",
6093                        long_long_unsigned_type_node);
6094   record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
6095   record_builtin_type (RID_MAX, "short unsigned int", short_unsigned_type_node);
6096   record_builtin_type (RID_MAX, "unsigned short", short_unsigned_type_node);
6097
6098   ptrdiff_type_node
6099     = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE)));
6100
6101   /* Define both `signed char' and `unsigned char'.  */
6102   record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
6103   record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
6104
6105   /* `unsigned long' is the standard type for sizeof.
6106      Note that stddef.h uses `unsigned long',
6107      and this must agree, even if long and int are the same size.  */
6108   set_sizetype
6109     (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE))));
6110
6111   /* Create the widest literal types. */
6112   widest_integer_literal_type_node = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
6113   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6114                         widest_integer_literal_type_node));
6115
6116   widest_unsigned_literal_type_node = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
6117   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6118                         widest_unsigned_literal_type_node));
6119
6120   /* These are types that type_for_size and type_for_mode use.  */
6121   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
6122   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
6123   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
6124   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
6125 #if HOST_BITS_PER_WIDE_INT >= 64
6126   pushdecl (build_decl (TYPE_DECL, get_identifier ("__int128_t"), intTI_type_node));
6127 #endif
6128   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
6129   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
6130   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
6131   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
6132 #if HOST_BITS_PER_WIDE_INT >= 64
6133   pushdecl (build_decl (TYPE_DECL, get_identifier ("__uint128_t"), unsigned_intTI_type_node));
6134 #endif
6135
6136   build_common_tree_nodes_2 (flag_short_double);
6137
6138   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6139   java_short_type_node = record_builtin_java_type ("__java_short", 16);
6140   java_int_type_node = record_builtin_java_type ("__java_int", 32);
6141   java_long_type_node = record_builtin_java_type ("__java_long", 64);
6142   java_float_type_node = record_builtin_java_type ("__java_float", -32);
6143   java_double_type_node = record_builtin_java_type ("__java_double", -64);
6144   java_char_type_node = record_builtin_java_type ("__java_char", -16);
6145   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6146
6147   integer_two_node = build_int_2 (2, 0);
6148   TREE_TYPE (integer_two_node) = integer_type_node;
6149   integer_three_node = build_int_2 (3, 0);
6150   TREE_TYPE (integer_three_node) = integer_type_node;
6151
6152   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6153   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6154   TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6155   TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6156   TYPE_PRECISION (boolean_type_node) = 1;
6157   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6158   boolean_false_node = build_int_2 (0, 0);
6159   TREE_TYPE (boolean_false_node) = boolean_type_node;
6160   boolean_true_node = build_int_2 (1, 0);
6161   TREE_TYPE (boolean_true_node) = boolean_type_node;
6162
6163   signed_size_zero_node = build_int_2 (0, 0);  record_builtin_type (RID_FLOAT, NULL_PTR, float_type_node);
6164   record_builtin_type (RID_DOUBLE, NULL_PTR, double_type_node);
6165   record_builtin_type (RID_MAX, "long double", long_double_type_node);
6166
6167   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
6168                         complex_integer_type_node));
6169   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
6170                         complex_float_type_node));
6171   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),
6172                         complex_double_type_node));
6173   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
6174                         complex_long_double_type_node));
6175
6176   TREE_TYPE (signed_size_zero_node) = make_signed_type (TYPE_PRECISION (sizetype));
6177
6178   record_builtin_type (RID_VOID, NULL_PTR, void_type_node);
6179   void_list_node = build_tree_list (NULL_TREE, void_type_node);
6180   TREE_PARMLIST (void_list_node) = 1;
6181
6182   /* Used for expressions that do nothing, but are not errors.  */
6183   void_zero_node = build_int_2 (0, 0);
6184   TREE_TYPE (void_zero_node) = void_type_node;
6185
6186   string_type_node = build_pointer_type (char_type_node);
6187   const_string_type_node
6188     = build_pointer_type (build_qualified_type (char_type_node,
6189                                                 TYPE_QUAL_CONST));
6190   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6191 #if 0
6192   record_builtin_type (RID_MAX, NULL_PTR, string_type_node);
6193 #endif
6194
6195   /* Make a type to be the domain of a few array types
6196      whose domains don't really matter.
6197      200 is small enough that it always fits in size_t
6198      and large enough that it can hold most function names for the
6199      initializations of __FUNCTION__ and __PRETTY_FUNCTION__.  */
6200   array_domain_type = build_index_type (build_int_2 (200, 0));
6201
6202   /* Make a type for arrays of characters.
6203      With luck nothing will ever really depend on the length of this
6204      array type.  */
6205   char_array_type_node
6206     = build_array_type (char_type_node, array_domain_type);
6207   /* Likewise for arrays of ints.  */
6208   int_array_type_node
6209     = build_array_type (integer_type_node, array_domain_type);
6210
6211   /* This is just some anonymous class type.  Nobody should ever
6212      need to look inside this envelope.  */
6213   class_star_type_node = build_pointer_type (make_aggr_type (RECORD_TYPE));
6214
6215   if (flag_huge_objects)
6216     delta_type_node = long_integer_type_node;
6217   else
6218     delta_type_node = short_integer_type_node;
6219
6220   default_function_type
6221     = build_function_type (integer_type_node, NULL_TREE);
6222
6223   ptr_type_node = build_pointer_type (void_type_node);
6224   const_ptr_type_node
6225     = build_pointer_type (build_qualified_type (void_type_node,
6226                                                 TYPE_QUAL_CONST));
6227   c_common_nodes_and_builtins (1, flag_no_builtin, flag_no_nonansi_builtin);
6228   lang_type_promotes_to = convert_type_from_ellipsis;
6229
6230   void_ftype_ptr
6231     = build_exception_variant (void_ftype_ptr, empty_except_spec);
6232
6233   /* C++ extensions */
6234
6235   unknown_type_node = make_node (UNKNOWN_TYPE);
6236   record_unknown_type (unknown_type_node, "unknown type");
6237
6238   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
6239   TREE_TYPE (unknown_type_node) = unknown_type_node;
6240
6241   TREE_TYPE (null_node) = type_for_size (POINTER_SIZE, 0);
6242
6243   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6244      result.  */
6245   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6246   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6247
6248   /* This is special for C++ so functions can be overloaded.  */
6249   wchar_type_node = get_identifier (flag_short_wchar
6250                                     ? "short unsigned int"
6251                                     : WCHAR_TYPE);
6252   wchar_type_node = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (wchar_type_node));
6253   wchar_type_size = TYPE_PRECISION (wchar_type_node);
6254   signed_wchar_type_node = make_signed_type (wchar_type_size);
6255   unsigned_wchar_type_node = make_unsigned_type (wchar_type_size);
6256   wchar_type_node
6257     = TREE_UNSIGNED (wchar_type_node)
6258       ? unsigned_wchar_type_node
6259       : signed_wchar_type_node;
6260   record_builtin_type (RID_WCHAR, "__wchar_t", wchar_type_node);
6261
6262   /* Artificial declaration of wchar_t -- can be bashed */
6263   wchar_decl_node = build_decl (TYPE_DECL, get_identifier ("wchar_t"),
6264                                 wchar_type_node);
6265   pushdecl (wchar_decl_node);
6266
6267   /* This is for wide string constants.  */
6268   wchar_array_type_node
6269     = build_array_type (wchar_type_node, array_domain_type);
6270
6271   if (flag_vtable_thunks)
6272     {
6273       /* Make sure we get a unique function type, so we can give
6274          its pointer type a name.  (This wins for gdb.) */
6275       tree vfunc_type = make_node (FUNCTION_TYPE);
6276       TREE_TYPE (vfunc_type) = integer_type_node;
6277       TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6278       layout_type (vfunc_type);
6279
6280       vtable_entry_type = build_pointer_type (vfunc_type);
6281     }
6282   else
6283     {
6284       vtable_entry_type = make_aggr_type (RECORD_TYPE);
6285       fields[0] = build_lang_decl (FIELD_DECL, delta_identifier,
6286                                    delta_type_node);
6287       fields[1] = build_lang_decl (FIELD_DECL, index_identifier,
6288                                    delta_type_node);
6289       fields[2] = build_lang_decl (FIELD_DECL, pfn_identifier,
6290                                    ptr_type_node);
6291       finish_builtin_type (vtable_entry_type, VTBL_PTR_TYPE, fields, 2,
6292                            double_type_node);
6293
6294       /* Make this part of an invisible union.  */
6295       fields[3] = copy_node (fields[2]);
6296       TREE_TYPE (fields[3]) = delta_type_node;
6297       DECL_NAME (fields[3]) = delta2_identifier;
6298       DECL_MODE (fields[3]) = TYPE_MODE (delta_type_node);
6299       DECL_SIZE (fields[3]) = TYPE_SIZE (delta_type_node);
6300       TREE_UNSIGNED (fields[3]) = 0;
6301       TREE_CHAIN (fields[2]) = fields[3];
6302       vtable_entry_type = build_qualified_type (vtable_entry_type,
6303                                                 TYPE_QUAL_CONST);
6304     }
6305   record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6306
6307   vtbl_type_node
6308     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6309   layout_type (vtbl_type_node);
6310   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6311   record_builtin_type (RID_MAX, NULL_PTR, vtbl_type_node);
6312   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6313   layout_type (vtbl_ptr_type_node);
6314   record_builtin_type (RID_MAX, NULL_PTR, vtbl_ptr_type_node);
6315
6316   std_node = build_decl (NAMESPACE_DECL,
6317                          get_identifier (flag_honor_std ? "fake std":"std"),
6318                          void_type_node);
6319   pushdecl (std_node);
6320
6321   global_type_node = make_node (LANG_TYPE);
6322   record_unknown_type (global_type_node, "global type");
6323
6324   /* Now, C++.  */
6325   current_lang_name = lang_name_cplusplus;
6326
6327   {
6328     tree bad_alloc_type_node, newtype, deltype;
6329     if (flag_honor_std)
6330       push_namespace (get_identifier ("std"));
6331     bad_alloc_type_node = xref_tag
6332       (class_type_node, get_identifier ("bad_alloc"), 1);
6333     if (flag_honor_std)
6334       pop_namespace ();
6335     newtype = build_exception_variant
6336       (ptr_ftype_sizetype, add_exception_specifier (NULL_TREE, bad_alloc_type_node, -1));
6337     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6338     auto_function (ansi_opname[(int) NEW_EXPR], newtype);
6339     auto_function (ansi_opname[(int) VEC_NEW_EXPR], newtype);
6340     global_delete_fndecl = auto_function (ansi_opname[(int) DELETE_EXPR],
6341                                           deltype);
6342     auto_function (ansi_opname[(int) VEC_DELETE_EXPR], deltype);
6343   }
6344
6345   abort_fndecl
6346     = define_function ("__pure_virtual", void_ftype, 0, 0);
6347
6348   /* Perform other language dependent initializations.  */
6349   init_class_processing ();
6350   init_init_processing ();
6351   init_search_processing ();
6352   init_rtti_processing ();
6353
6354   if (flag_exceptions)
6355     init_exception_processing ();
6356   if (flag_no_inline)
6357     {
6358       flag_inline_functions = 0;
6359     }
6360
6361   if (! supports_one_only ())
6362     flag_weak = 0;
6363
6364   /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__.  */
6365   declare_function_name ();
6366
6367   /* Prepare to check format strings against argument lists.  */
6368   init_function_format_info ();
6369
6370   /* Show we use EH for cleanups.  */
6371   using_eh_for_cleanups ();
6372
6373   print_error_function = lang_print_error_function;
6374   lang_get_alias_set = &c_get_alias_set;
6375   valid_lang_attribute = cp_valid_lang_attribute;
6376
6377   /* Maintain consistency.  Perhaps we should just complain if they
6378      say -fwritable-strings?  */
6379   if (flag_writable_strings)
6380     flag_const_strings = 0;
6381
6382   /* Add GC roots for all of our global variables.  */
6383   ggc_add_tree_root (c_global_trees, sizeof c_global_trees / sizeof(tree));
6384   ggc_add_tree_root (cp_global_trees, sizeof cp_global_trees / sizeof(tree));
6385   ggc_add_tree_root (&integer_three_node, 1);
6386   ggc_add_tree_root (&integer_two_node, 1);
6387   ggc_add_tree_root (&signed_size_zero_node, 1);
6388   ggc_add_tree_root (&size_one_node, 1);
6389   ggc_add_tree_root (&size_zero_node, 1);
6390   ggc_add_root (&global_binding_level, 1, sizeof global_binding_level,
6391                 mark_binding_level);
6392   ggc_add_root (&scope_chain, 1, sizeof scope_chain, &mark_saved_scope);
6393   ggc_add_tree_root (&static_ctors, 1);
6394   ggc_add_tree_root (&static_dtors, 1);
6395   ggc_add_tree_root (&lastiddecl, 1);
6396
6397   ggc_add_tree_root (&last_function_parm_tags, 1);
6398   ggc_add_tree_root (&current_function_return_value, 1);
6399   ggc_add_tree_root (&current_function_parms, 1);
6400   ggc_add_tree_root (&current_function_parm_tags, 1);
6401   ggc_add_tree_root (&last_function_parms, 1);
6402   ggc_add_tree_root (&error_mark_list, 1);
6403
6404   ggc_add_tree_root (&global_namespace, 1);
6405   ggc_add_tree_root (&global_type_node, 1);
6406   ggc_add_tree_root (&anonymous_namespace_name, 1);
6407
6408   ggc_add_tree_root (&got_object, 1);
6409   ggc_add_tree_root (&got_scope, 1);
6410
6411   ggc_add_tree_root (&current_lang_name, 1);
6412   ggc_add_tree_root (&static_aggregates, 1);
6413 }
6414
6415 /* Function to print any language-specific context for an error message.  */
6416
6417 static void
6418 lang_print_error_function (file)
6419      const char *file;
6420 {
6421   default_print_error_function (file);
6422   maybe_print_template_context ();
6423 }
6424
6425 /* Make a definition for a builtin function named NAME and whose data type
6426    is TYPE.  TYPE should be a function type with argument types.
6427
6428    If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6429    the name to be called if we can't opencode the function.  */
6430
6431 tree
6432 define_function (name, type, pfn, library_name)
6433      const char *name;
6434      tree type;
6435      void (*pfn) PARAMS ((tree));
6436      const char *library_name;
6437 {
6438   tree decl = build_lang_decl (FUNCTION_DECL, get_identifier (name), type);
6439   DECL_EXTERNAL (decl) = 1;
6440   TREE_PUBLIC (decl) = 1;
6441   DECL_ARTIFICIAL (decl) = 1;
6442
6443   my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 392);
6444   DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
6445
6446   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6447      we cannot change DECL_ASSEMBLER_NAME until we have installed this
6448      function in the namespace.  */
6449   if (pfn) (*pfn) (decl);
6450   if (library_name)
6451     DECL_ASSEMBLER_NAME (decl) = get_identifier (library_name);
6452   make_function_rtl (decl);
6453   return decl;
6454 }
6455
6456
6457 /* Wrapper around define_function, for the benefit of
6458    c_common_nodes_and_builtins.
6459    FUNCTION_CODE tells later passes how to compile calls to this function.
6460    See tree.h for its possible values.  */
6461
6462 tree
6463 builtin_function (name, type, code, class, libname)
6464      const char *name;
6465      tree type;
6466      int code;
6467      enum built_in_class class;
6468      const char *libname;
6469 {
6470   tree decl = define_function (name, type, (void (*) PARAMS ((tree)))pushdecl,
6471                                libname);
6472   DECL_BUILT_IN_CLASS (decl) = class;
6473   DECL_FUNCTION_CODE (decl) = code;
6474   return decl;
6475 }
6476 \f
6477 /* When we call finish_struct for an anonymous union, we create
6478    default copy constructors and such.  But, an anonymous union
6479    shouldn't have such things; this function undoes the damage to the
6480    anonymous union type T.
6481
6482    (The reason that we create the synthesized methods is that we don't
6483    distinguish `union { int i; }' from `typedef union { int i; } U'.
6484    The first is an anonymous union; the second is just an ordinary
6485    union type.)  */
6486
6487 void
6488 fixup_anonymous_aggr (t)
6489      tree t;
6490 {
6491   tree *q;
6492
6493   /* Wipe out memory of synthesized methods */
6494   TYPE_HAS_CONSTRUCTOR (t) = 0;
6495   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6496   TYPE_HAS_INIT_REF (t) = 0;
6497   TYPE_HAS_CONST_INIT_REF (t) = 0;
6498   TYPE_HAS_ASSIGN_REF (t) = 0;
6499   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6500
6501   /* Splice the implicitly generated functions out of the TYPE_METHODS
6502      list.  */
6503   q = &TYPE_METHODS (t);
6504   while (*q)
6505     {
6506       if (DECL_ARTIFICIAL (*q))
6507         *q = TREE_CHAIN (*q);
6508       else
6509         q = &TREE_CHAIN (*q);
6510     }
6511
6512   /* ANSI C++ June 5 1992 WP 9.5.3.  Anonymous unions may not have
6513      function members.  */
6514   if (TYPE_METHODS (t))
6515     error ("an anonymous union cannot have function members");
6516 }
6517
6518 /* Make sure that a declaration with no declarator is well-formed, i.e.
6519    just defines a tagged type or anonymous union.
6520
6521    Returns the type defined, if any.  */
6522
6523 tree
6524 check_tag_decl (declspecs)
6525      tree declspecs;
6526 {
6527   int found_type = 0;
6528   tree ob_modifier = NULL_TREE;
6529   register tree link;
6530   register tree t = NULL_TREE;
6531
6532   for (link = declspecs; link; link = TREE_CHAIN (link))
6533     {
6534       register tree value = TREE_VALUE (link);
6535
6536       if (TYPE_P (value))
6537         {
6538           ++found_type;
6539
6540           if (IS_AGGR_TYPE (value) || TREE_CODE (value) == ENUMERAL_TYPE)
6541             {
6542               my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
6543               t = value;
6544             }
6545         }
6546       else if (value == ridpointers[(int) RID_FRIEND])
6547         {
6548           if (current_class_type == NULL_TREE
6549               || current_scope () != current_class_type)
6550             ob_modifier = value;
6551         }
6552       else if (value == ridpointers[(int) RID_STATIC]
6553                || value == ridpointers[(int) RID_EXTERN]
6554                || value == ridpointers[(int) RID_AUTO]
6555                || value == ridpointers[(int) RID_REGISTER]
6556                || value == ridpointers[(int) RID_INLINE]
6557                || value == ridpointers[(int) RID_VIRTUAL]
6558                || value == ridpointers[(int) RID_CONST]
6559                || value == ridpointers[(int) RID_VOLATILE]
6560                || value == ridpointers[(int) RID_EXPLICIT])
6561         ob_modifier = value;
6562     }
6563
6564   if (found_type > 1)
6565     error ("multiple types in one declaration");
6566
6567   /* Inside a class, we might be in a friend or access declaration.
6568      Until we have a good way of detecting the latter, don't warn.  */
6569   if (t == NULL_TREE && ! current_class_type)
6570     pedwarn ("declaration does not declare anything");
6571
6572   /* Check for an anonymous union.  We're careful
6573      accessing TYPE_IDENTIFIER because some built-in types, like
6574      pointer-to-member types, do not have TYPE_NAME.  */
6575   else if (t && IS_AGGR_TYPE_CODE (TREE_CODE (t))
6576            && TYPE_NAME (t)
6577            && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
6578     {
6579       /* Anonymous unions are objects, so they can have specifiers.  */;
6580       SET_ANON_AGGR_TYPE_P (t);
6581
6582       if (TREE_CODE (t) != UNION_TYPE && pedantic && ! in_system_header)
6583         pedwarn ("ISO C++ prohibits anonymous structs");
6584     }
6585
6586   else if (ob_modifier)
6587     {
6588       if (ob_modifier == ridpointers[(int) RID_INLINE]
6589           || ob_modifier == ridpointers[(int) RID_VIRTUAL])
6590         cp_error ("`%D' can only be specified for functions", ob_modifier);
6591       else if (ob_modifier == ridpointers[(int) RID_FRIEND])
6592         cp_error ("`%D' can only be specified inside a class", ob_modifier);
6593       else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
6594         cp_error ("`%D' can only be specified for constructors",
6595                   ob_modifier);
6596       else
6597         cp_error ("`%D' can only be specified for objects and functions",
6598                   ob_modifier);
6599     }
6600
6601   return t;
6602 }
6603
6604 /* Called when a declaration is seen that contains no names to declare.
6605    If its type is a reference to a structure, union or enum inherited
6606    from a containing scope, shadow that tag name for the current scope
6607    with a forward reference.
6608    If its type defines a new named structure or union
6609    or defines an enum, it is valid but we need not do anything here.
6610    Otherwise, it is an error.
6611
6612    C++: may have to grok the declspecs to learn about static,
6613    complain for anonymous unions.  */
6614
6615 void
6616 shadow_tag (declspecs)
6617      tree declspecs;
6618 {
6619   tree t = check_tag_decl (declspecs);
6620
6621   if (t)
6622     maybe_process_partial_specialization (t);
6623
6624   /* This is where the variables in an anonymous union are
6625      declared.  An anonymous union declaration looks like:
6626      union { ... } ;
6627      because there is no declarator after the union, the parser
6628      sends that declaration here.  */
6629   if (t && ANON_AGGR_TYPE_P (t))
6630     {
6631       fixup_anonymous_aggr (t);
6632
6633       if (TYPE_FIELDS (t))
6634         {
6635           tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
6636                                       NULL_TREE);
6637           finish_anon_union (decl);
6638         }
6639     }
6640 }
6641 \f
6642 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
6643
6644 tree
6645 groktypename (typename)
6646      tree typename;
6647 {
6648   if (TREE_CODE (typename) != TREE_LIST)
6649     return typename;
6650   return grokdeclarator (TREE_VALUE (typename),
6651                          TREE_PURPOSE (typename),
6652                          TYPENAME, 0, NULL_TREE);
6653 }
6654
6655 /* Decode a declarator in an ordinary declaration or data definition.
6656    This is called as soon as the type information and variable name
6657    have been parsed, before parsing the initializer if any.
6658    Here we create the ..._DECL node, fill in its type,
6659    and put it on the list of decls for the current context.
6660    The ..._DECL node is returned as the value.
6661
6662    Exception: for arrays where the length is not specified,
6663    the type is left null, to be filled in by `cp_finish_decl'.
6664
6665    Function definitions do not come here; they go to start_function
6666    instead.  However, external and forward declarations of functions
6667    do go through here.  Structure field declarations are done by
6668    grokfield and not through here.  */
6669
6670 /* Set this to zero to debug not using the temporary obstack
6671    to parse initializers.  */
6672 int debug_temp_inits = 1;
6673
6674 tree
6675 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
6676      tree declarator, declspecs;
6677      int initialized;
6678      tree attributes, prefix_attributes;
6679 {
6680   register tree decl;
6681   register tree type, tem;
6682   tree context;
6683   extern int have_extern_spec;
6684   extern int used_extern_spec;
6685   tree attrlist;
6686
6687 #if 0
6688   /* See code below that used this.  */
6689   int init_written = initialized;
6690 #endif
6691
6692   /* This should only be done once on the top most decl.  */
6693   if (have_extern_spec && !used_extern_spec)
6694     {
6695       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"),
6696                                   declspecs);
6697       used_extern_spec = 1;
6698     }
6699
6700   if (attributes || prefix_attributes)
6701     attrlist = build_tree_list (attributes, prefix_attributes);
6702   else
6703     attrlist = NULL_TREE;
6704
6705   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
6706                          attrlist);
6707
6708   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
6709     return NULL_TREE;
6710
6711   type = TREE_TYPE (decl);
6712
6713   if (type == error_mark_node)
6714     return NULL_TREE;
6715
6716   context
6717     = (TREE_CODE (decl) == FUNCTION_DECL && DECL_VIRTUAL_P (decl))
6718       ? DECL_CLASS_CONTEXT (decl)
6719       : DECL_CONTEXT (decl);
6720
6721   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
6722       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
6723     {
6724       /* When parsing the initializer, lookup should use the object's
6725          namespace. */
6726       push_decl_namespace (context);
6727     }
6728
6729   /* We are only interested in class contexts, later. */
6730   if (context && TREE_CODE (context) == NAMESPACE_DECL)
6731     context = NULL_TREE;
6732
6733   if (initialized)
6734     /* Is it valid for this decl to have an initializer at all?
6735        If not, set INITIALIZED to zero, which will indirectly
6736        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
6737     switch (TREE_CODE (decl))
6738       {
6739       case TYPE_DECL:
6740         /* typedef foo = bar  means give foo the same type as bar.
6741            We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
6742            Any other case of an initialization in a TYPE_DECL is an error.  */
6743         if (pedantic || list_length (declspecs) > 1)
6744           {
6745             cp_error ("typedef `%D' is initialized", decl);
6746             initialized = 0;
6747           }
6748         break;
6749
6750       case FUNCTION_DECL:
6751         cp_error ("function `%#D' is initialized like a variable", decl);
6752         initialized = 0;
6753         break;
6754
6755       default:
6756         break;
6757       }
6758
6759   if (initialized)
6760     {
6761       if (! toplevel_bindings_p ()
6762           && DECL_EXTERNAL (decl))
6763         cp_warning ("declaration of `%#D' has `extern' and is initialized",
6764                     decl);
6765       DECL_EXTERNAL (decl) = 0;
6766       if (toplevel_bindings_p ())
6767         TREE_STATIC (decl) = 1;
6768
6769       /* Tell `pushdecl' this is an initialized decl
6770          even though we don't yet have the initializer expression.
6771          Also tell `cp_finish_decl' it may store the real initializer.  */
6772       DECL_INITIAL (decl) = error_mark_node;
6773     }
6774
6775 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
6776   SET_DEFAULT_DECL_ATTRIBUTES (decl, attributes);
6777 #endif
6778
6779   /* Set attributes here so if duplicate decl, will have proper attributes.  */
6780   cplus_decl_attributes (decl, attributes, prefix_attributes);
6781
6782   if (context && TYPE_SIZE (complete_type (context)) != NULL_TREE)
6783     {
6784       push_nested_class (context, 2);
6785
6786       if (TREE_CODE (decl) == VAR_DECL)
6787         {
6788           tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
6789           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
6790             cp_error ("`%#D' is not a static member of `%#T'", decl, context);
6791           else
6792             {
6793               if (DECL_CONTEXT (field) != context)
6794                 {
6795                   cp_pedwarn ("ANSI C++ does not permit `%T::%D' to be defined as `%T::%D'",
6796                               DECL_CONTEXT (field), DECL_NAME (decl),
6797                               context, DECL_NAME (decl));
6798                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
6799                 }
6800               /* Static data member are tricky; an in-class initialization
6801                  still doesn't provide a definition, so the in-class
6802                  declaration will have DECL_EXTERNAL set, but will have an
6803                  initialization.  Thus, duplicate_decls won't warn
6804                  about this situation, and so we check here.  */
6805               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
6806                 cp_error ("duplicate initialization of %D", decl);
6807               if (duplicate_decls (decl, field))
6808                 decl = field;
6809             }
6810         }
6811       else
6812         {
6813           tree field = check_classfn (context, decl);
6814           if (field && duplicate_decls (decl, field))
6815             decl = field;
6816         }
6817
6818       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
6819       DECL_IN_AGGR_P (decl) = 0;
6820       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
6821           || CLASSTYPE_USE_TEMPLATE (context))
6822         {
6823           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
6824           /* [temp.expl.spec] An explicit specialization of a static data
6825              member of a template is a definition if the declaration
6826              includes an initializer; otherwise, it is a declaration.
6827
6828              We check for processing_specialization so this only applies
6829              to the new specialization syntax.  */
6830           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
6831             DECL_EXTERNAL (decl) = 1;
6832         }
6833
6834       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
6835         cp_pedwarn ("declaration of `%#D' outside of class is not definition",
6836                     decl);
6837     }
6838
6839   /* Enter this declaration into the symbol table.  */
6840   tem = maybe_push_decl (decl);
6841
6842   if (processing_template_decl)
6843     tem = push_template_decl (tem);
6844
6845 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
6846   /* Tell the back-end to use or not use .common as appropriate.  If we say
6847      -fconserve-space, we want this to save .data space, at the expense of
6848      wrong semantics.  If we say -fno-conserve-space, we want this to
6849      produce errors about redefs; to do this we force variables into the
6850      data segment.  */
6851   DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
6852 #endif
6853
6854   if (! processing_template_decl)
6855     start_decl_1 (tem);
6856
6857   return tem;
6858 }
6859
6860 void
6861 start_decl_1 (decl)
6862      tree decl;
6863 {
6864   tree type = TREE_TYPE (decl);
6865   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
6866
6867   if (type == error_mark_node)
6868     return;
6869
6870   /* If this type of object needs a cleanup, but we're not allowed to
6871      add any more objects with cleanups to the current scope, create a
6872      new binding level.  */
6873   if (TYPE_NEEDS_DESTRUCTOR (type)
6874       && current_binding_level->more_cleanups_ok == 0)
6875     {
6876       keep_next_level (2);
6877       pushlevel (1);
6878       clear_last_expr ();
6879       add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
6880     }
6881
6882   if (initialized)
6883     /* Is it valid for this decl to have an initializer at all?
6884        If not, set INITIALIZED to zero, which will indirectly
6885        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
6886     {
6887       /* Don't allow initializations for incomplete types except for
6888          arrays which might be completed by the initialization.  */
6889       if (TYPE_SIZE (complete_type (type)) != NULL_TREE)
6890         ;                       /* A complete type is ok.  */
6891       else if (TREE_CODE (type) != ARRAY_TYPE)
6892         {
6893           cp_error ("variable `%#D' has initializer but incomplete type",
6894                     decl);
6895           initialized = 0;
6896           type = TREE_TYPE (decl) = error_mark_node;
6897         }
6898       else if (TYPE_SIZE (complete_type (TREE_TYPE (type))) == NULL_TREE)
6899         {
6900           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
6901             cp_error ("elements of array `%#D' have incomplete type", decl);
6902           /* else we already gave an error in start_decl.  */
6903           initialized = 0;
6904         }
6905     }
6906
6907   if (!initialized
6908       && TREE_CODE (decl) != TYPE_DECL
6909       && TREE_CODE (decl) != TEMPLATE_DECL
6910       && type != error_mark_node
6911       && IS_AGGR_TYPE (type)
6912       && ! DECL_EXTERNAL (decl))
6913     {
6914       if ((! processing_template_decl || ! uses_template_parms (type))
6915           && TYPE_SIZE (complete_type (type)) == NULL_TREE)
6916         {
6917           cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
6918                  decl);
6919           /* Change the type so that assemble_variable will give
6920              DECL an rtl we can live with: (mem (const_int 0)).  */
6921           type = TREE_TYPE (decl) = error_mark_node;
6922         }
6923       else
6924         {
6925           /* If any base type in the hierarchy of TYPE needs a constructor,
6926              then we set initialized to 1.  This way any nodes which are
6927              created for the purposes of initializing this aggregate
6928              will live as long as it does.  This is necessary for global
6929              aggregates which do not have their initializers processed until
6930              the end of the file.  */
6931           initialized = TYPE_NEEDS_CONSTRUCTING (type);
6932         }
6933     }
6934
6935   if (! initialized)
6936     DECL_INITIAL (decl) = NULL_TREE;
6937 }
6938
6939 /* Handle initialization of references.
6940    These three arguments are from `cp_finish_decl', and have the
6941    same meaning here that they do there.
6942
6943    Quotes on semantics can be found in ARM 8.4.3.  */
6944
6945 static void
6946 grok_reference_init (decl, type, init)
6947      tree decl, type, init;
6948 {
6949   tree tmp;
6950
6951   if (init == NULL_TREE)
6952     {
6953       if ((DECL_LANG_SPECIFIC (decl) == 0
6954            || DECL_IN_AGGR_P (decl) == 0)
6955           && ! DECL_THIS_EXTERN (decl))
6956         cp_error ("`%D' declared as reference but not initialized", decl);
6957       return;
6958     }
6959
6960   if (init == error_mark_node)
6961     return;
6962
6963   if (TREE_CODE (init) == CONSTRUCTOR)
6964     {
6965       cp_error ("ANSI C++ forbids use of initializer list to initialize reference `%D'", decl);
6966       return;
6967     }
6968
6969   if (TREE_CODE (init) == TREE_LIST)
6970     init = build_compound_expr (init);
6971
6972   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
6973     init = convert_from_reference (init);
6974
6975   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
6976       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
6977     {
6978       /* Note: default conversion is only called in very special cases.  */
6979       init = default_conversion (init);
6980     }
6981
6982   /* Convert INIT to the reference type TYPE.  This may involve the
6983      creation of a temporary, whose lifetime must be the same as that
6984      of the reference.  If so, a DECL_STMT for the temporary will be
6985      added just after the DECL_STMT for DECL.  That's why we don't set
6986      DECL_INITIAL for local references (instead assigning to them
6987      explicitly); we need to allow the temporary to be initialized
6988      first.  */
6989   tmp = convert_to_reference
6990     (type, init, CONV_IMPLICIT,
6991      LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND, decl);
6992
6993   if (tmp == error_mark_node)
6994     return;
6995   else if (tmp != NULL_TREE)
6996     {
6997       init = tmp;
6998       tmp = save_expr (tmp);
6999       if (building_stmt_tree ())
7000         {
7001           /* Initialize the declaration.  */
7002           tmp = build (INIT_EXPR, TREE_TYPE (decl), decl, tmp);
7003           finish_expr_stmt (tmp);
7004         }
7005       else
7006         DECL_INITIAL (decl) = tmp;
7007     }
7008   else
7009     {
7010       cp_error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
7011       return;
7012     }
7013
7014   if (TREE_STATIC (decl) && ! TREE_CONSTANT (DECL_INITIAL (decl)))
7015     {
7016       expand_static_init (decl, DECL_INITIAL (decl));
7017       DECL_INITIAL (decl) = NULL_TREE;
7018     }
7019   return;
7020 }
7021
7022 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7023    mucking with forces it does not comprehend (i.e. initialization with a
7024    constructor).  If we are at global scope and won't go into COMMON, fill
7025    it in with a dummy CONSTRUCTOR to force the variable into .data;
7026    otherwise we can use error_mark_node.  */
7027
7028 static tree
7029 obscure_complex_init (decl, init)
7030      tree decl, init;
7031 {
7032   if (! flag_no_inline && TREE_STATIC (decl))
7033     {
7034       if (extract_init (decl, init))
7035         return NULL_TREE;
7036     }
7037
7038 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7039   if (toplevel_bindings_p () && ! DECL_COMMON (decl))
7040     DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
7041                                  NULL_TREE);
7042   else
7043 #endif
7044     DECL_INITIAL (decl) = error_mark_node;
7045
7046   return init;
7047 }
7048
7049 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7050    array until we finish parsing the initializer.  If that's the
7051    situation we're in, update DECL accordingly.  */
7052
7053 static void
7054 maybe_deduce_size_from_array_init (decl, init)
7055      tree decl;
7056      tree init;
7057 {
7058   tree type = TREE_TYPE (decl);
7059
7060   if (TREE_CODE (type) == ARRAY_TYPE
7061       && TYPE_DOMAIN (type) == NULL_TREE
7062       && TREE_CODE (decl) != TYPE_DECL)
7063     {
7064       int do_default
7065         = (TREE_STATIC (decl)
7066            /* Even if pedantic, an external linkage array
7067               may have incomplete type at first.  */
7068            ? pedantic && ! DECL_EXTERNAL (decl)
7069            : !DECL_EXTERNAL (decl));
7070       tree initializer = init ? init : DECL_INITIAL (decl);
7071       int failure = complete_array_type (type, initializer, do_default);
7072
7073       if (failure == 1)
7074         cp_error ("initializer fails to determine size of `%D'", decl);
7075
7076       if (failure == 2)
7077         {
7078           if (do_default)
7079             cp_error ("array size missing in `%D'", decl);
7080           /* If a `static' var's size isn't known, make it extern as
7081              well as static, so it does not get allocated.  If it's not
7082              `static', then don't mark it extern; finish_incomplete_decl
7083              will give it a default size and it will get allocated.  */
7084           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7085             DECL_EXTERNAL (decl) = 1;
7086         }
7087
7088       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7089           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7090                               integer_zero_node))
7091         cp_error ("zero-size array `%D'", decl);
7092
7093       layout_decl (decl, 0);
7094     }
7095 }
7096
7097 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7098    any appropriate error messages regarding the layout.  */
7099
7100 static void
7101 layout_var_decl (decl)
7102      tree decl;
7103 {
7104   tree type = TREE_TYPE (decl);
7105 #if 0
7106   tree ttype = target_type (type);
7107 #endif
7108
7109   /* If we haven't already layed out this declaration, do so now.
7110      Note that we must not call complete type for an external object
7111      because it's type might involve templates that we are not
7112      supposed to isntantiate yet.  (And it's perfectly legal to say
7113      `extern X x' for some incomplete type `X'.)  */
7114   if (!DECL_EXTERNAL (decl))
7115     complete_type (type);
7116   if (!DECL_SIZE (decl)&& TYPE_SIZE (type))
7117     layout_decl (decl, 0);
7118
7119   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7120     {
7121       /* An automatic variable with an incomplete type: that is an error.
7122          Don't talk about array types here, since we took care of that
7123          message in grokdeclarator.  */
7124       cp_error ("storage size of `%D' isn't known", decl);
7125       TREE_TYPE (decl) = error_mark_node;
7126     }
7127 #if 0
7128   /* Keep this code around in case we later want to control debug info
7129      based on whether a type is "used".  (jason 1999-11-11) */
7130
7131   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7132     /* Let debugger know it should output info for this type.  */
7133     note_debug_info_needed (ttype);
7134
7135   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7136     note_debug_info_needed (DECL_CONTEXT (decl));
7137 #endif
7138
7139   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7140       && DECL_SIZE (decl) != NULL_TREE
7141       && ! TREE_CONSTANT (DECL_SIZE (decl)))
7142     {
7143       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7144         constant_expression_warning (DECL_SIZE (decl));
7145       else
7146         cp_error ("storage size of `%D' isn't constant", decl);
7147     }
7148 }
7149
7150 /* If a local static variable is declared in an inline function, or if
7151    we have a weak definition, we must endeavor to create only one
7152    instance of the variable at link-time.  */
7153
7154 static void
7155 maybe_commonize_var (decl)
7156      tree decl;
7157 {
7158   /* Static data in a function with comdat linkage also has comdat
7159      linkage.  */
7160   if (TREE_STATIC (decl)
7161       /* Don't mess with __FUNCTION__.  */
7162       && ! TREE_ASM_WRITTEN (decl)
7163       && current_function_decl
7164       && DECL_CONTEXT (decl) == current_function_decl
7165       && (DECL_THIS_INLINE (current_function_decl)
7166           || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7167       && TREE_PUBLIC (current_function_decl))
7168     {
7169       /* Rather than try to get this right with inlining, we suppress
7170          inlining of such functions.  */
7171       current_function_cannot_inline
7172         = "function with static variable cannot be inline";
7173
7174       /* If flag_weak, we don't need to mess with this, as we can just
7175          make the function weak, and let it refer to its unique local
7176          copy.  This works because we don't allow the function to be
7177          inlined.  */
7178       if (! flag_weak)
7179         {
7180           if (DECL_INTERFACE_KNOWN (current_function_decl))
7181             {
7182               TREE_PUBLIC (decl) = 1;
7183               DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7184             }
7185           else if (DECL_INITIAL (decl) == NULL_TREE
7186                    || DECL_INITIAL (decl) == error_mark_node)
7187             {
7188               TREE_PUBLIC (decl) = 1;
7189               DECL_COMMON (decl) = 1;
7190             }
7191           /* else we lose. We can only do this if we can use common,
7192              which we can't if it has been initialized.  */
7193
7194           if (TREE_PUBLIC (decl))
7195             DECL_ASSEMBLER_NAME (decl)
7196               = build_static_name (current_function_decl, DECL_NAME (decl));
7197           else if (! DECL_ARTIFICIAL (decl))
7198             {
7199               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7200               cp_warning_at ("  you can work around this by removing the initializer", decl);
7201             }
7202         }
7203     }
7204   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7205     /* Set it up again; we might have set DECL_INITIAL since the last
7206        time.  */
7207     comdat_linkage (decl);
7208 }
7209
7210 /* Issue an error message if DECL is an uninitialized const variable.  */
7211
7212 static void
7213 check_for_uninitialized_const_var (decl)
7214      tree decl;
7215 {
7216   tree type = TREE_TYPE (decl);
7217
7218   /* ``Unless explicitly declared extern, a const object does not have
7219      external linkage and must be initialized. ($8.4; $12.1)'' ARM
7220      7.1.6 */
7221   if (TREE_CODE (decl) == VAR_DECL
7222       && TREE_CODE (type) != REFERENCE_TYPE
7223       && CP_TYPE_CONST_P (type)
7224       && !TYPE_NEEDS_CONSTRUCTING (type)
7225       && !DECL_INITIAL (decl))
7226     cp_error ("uninitialized const `%D'", decl);
7227 }
7228
7229 /* Verify INIT (the initializer for DECL), and record the
7230    initialization in DECL_INITIAL, if appropriate.  Returns a new
7231    value for INIT.  */
7232
7233 static tree
7234 check_initializer (decl, init)
7235      tree decl;
7236      tree init;
7237 {
7238   tree type;
7239
7240   if (TREE_CODE (decl) == FIELD_DECL)
7241     return init;
7242
7243   type = TREE_TYPE (decl);
7244
7245   /* If `start_decl' didn't like having an initialization, ignore it now.  */
7246   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7247     init = NULL_TREE;
7248
7249   /* Check the initializer.  */
7250   if (init)
7251     {
7252       /* Things that are going to be initialized need to have complete
7253          type.  */
7254       TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7255
7256       if (type == error_mark_node)
7257         /* We will have already complained.  */
7258         init = NULL_TREE;
7259       else if (TYPE_SIZE (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
7260         {
7261           cp_error ("variable-sized object `%D' may not be initialized", decl);
7262           init = NULL_TREE;
7263         }
7264       else if (TREE_CODE (type) == ARRAY_TYPE
7265                && !TYPE_SIZE (TREE_TYPE (type)))
7266         {
7267           cp_error ("elements of array `%#D' have incomplete type", decl);
7268           init = NULL_TREE;
7269         }
7270       else if (!TYPE_SIZE (type))
7271         {
7272           cp_error ("`%D' has incomplete type", decl);
7273           TREE_TYPE (decl) = error_mark_node;
7274           init = NULL_TREE;
7275         }
7276     }
7277
7278   if (TREE_CODE (decl) == CONST_DECL)
7279     {
7280       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7281
7282       DECL_INITIAL (decl) = init;
7283
7284       /* This will keep us from needing to worry about our obstacks.  */
7285       my_friendly_assert (init != NULL_TREE, 149);
7286       init = NULL_TREE;
7287     }
7288   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7289     {
7290       if (TREE_STATIC (decl))
7291         make_decl_rtl (decl, NULL_PTR, toplevel_bindings_p ());
7292       grok_reference_init (decl, type, init);
7293       init = NULL_TREE;
7294     }
7295   else if (init)
7296     {
7297       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7298         {
7299           if (TREE_CODE (type) == ARRAY_TYPE)
7300             init = digest_init (type, init, (tree *) 0);
7301           else if (TREE_CODE (init) == CONSTRUCTOR
7302                    && TREE_HAS_CONSTRUCTOR (init))
7303             {
7304               if (TYPE_NON_AGGREGATE_CLASS (type))
7305                 {
7306                   cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7307                             decl);
7308                   init = error_mark_node;
7309                 }
7310               else
7311                 goto dont_use_constructor;
7312             }
7313         }
7314       else
7315         {
7316         dont_use_constructor:
7317           if (TREE_CODE (init) != TREE_VEC)
7318             init = store_init_value (decl, init);
7319         }
7320
7321       if (init)
7322         /* We must hide the initializer so that expand_decl
7323            won't try to do something it does not understand.  */
7324         init = obscure_complex_init (decl, init);
7325     }
7326   else if (DECL_EXTERNAL (decl))
7327     ;
7328   else if (TREE_CODE_CLASS (TREE_CODE (type)) == 't'
7329            && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
7330     {
7331       tree core_type = strip_array_types (type);
7332
7333       if (! TYPE_NEEDS_CONSTRUCTING (core_type))
7334         {
7335           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
7336             cp_error ("structure `%D' with uninitialized const members", decl);
7337           if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
7338             cp_error ("structure `%D' with uninitialized reference members",
7339                       decl);
7340         }
7341
7342       check_for_uninitialized_const_var (decl);
7343
7344       if (TYPE_SIZE (type) != NULL_TREE
7345           && TYPE_NEEDS_CONSTRUCTING (type))
7346         init = obscure_complex_init (decl, NULL_TREE);
7347
7348     }
7349   else
7350     check_for_uninitialized_const_var (decl);
7351
7352   return init;
7353 }
7354
7355 /* If DECL is not a local variable, give it RTL.  */
7356
7357 static void
7358 make_rtl_for_nonlocal_decl (decl, init, asmspec)
7359      tree decl;
7360      tree init;
7361      const char *asmspec;
7362 {
7363   int toplev;
7364   tree type;
7365
7366   type = TREE_TYPE (decl);
7367   toplev = toplevel_bindings_p ();
7368
7369   /* Handle non-variables up front.  */
7370   if (TREE_CODE (decl) != VAR_DECL)
7371     {
7372       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7373       return;
7374     }
7375
7376   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
7377   if (asmspec)
7378     DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
7379
7380   if (DECL_VIRTUAL_P (decl))
7381     make_decl_rtl (decl, NULL_PTR, toplev);
7382   else if (TREE_READONLY (decl)
7383            && DECL_INITIAL (decl) != NULL_TREE
7384            && DECL_INITIAL (decl) != error_mark_node
7385            && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl)))
7386     {
7387       DECL_INITIAL (decl) = save_expr (DECL_INITIAL (decl));
7388
7389       if (toplev && ! TREE_PUBLIC (decl))
7390         {
7391           /* If this is a static const, change its apparent linkage
7392              if it belongs to a #pragma interface.  */
7393           if (!interface_unknown)
7394             {
7395               TREE_PUBLIC (decl) = 1;
7396               DECL_EXTERNAL (decl) = interface_only;
7397             }
7398           make_decl_rtl (decl, asmspec, toplev);
7399         }
7400       else if (toplev)
7401         rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7402     }
7403   else if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
7404     {
7405       my_friendly_assert (TREE_STATIC (decl), 19990828);
7406
7407       if (init == NULL_TREE
7408 #ifdef DEFAULT_STATIC_DEFS
7409           /* If this code is dead, then users must
7410              explicitly declare static member variables
7411              outside the class def'n as well.  */
7412           && TYPE_NEEDS_CONSTRUCTING (type)
7413 #endif
7414           )
7415         {
7416           DECL_EXTERNAL (decl) = 1;
7417           make_decl_rtl (decl, asmspec, 1);
7418         }
7419       else
7420         rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7421     }
7422   else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == NAMESPACE_DECL
7423            || (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl)))
7424     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7425 }
7426
7427 /* Create RTL for the local static variable DECL.  */
7428
7429 void
7430 make_rtl_for_local_static (decl)
7431      tree decl;
7432 {
7433   const char *asmspec = NULL;
7434
7435   /* If we inlined this variable, we could see it's declaration
7436      again.  */
7437   if (DECL_RTL (decl))
7438     return;
7439
7440   if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
7441     {
7442       /* The only way this situaton can occur is if the
7443          user specified a name for this DECL using the
7444          `attribute' syntax.  */
7445       asmspec = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
7446       DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
7447     }
7448
7449   rest_of_decl_compilation (decl, asmspec, /*top_level=*/0, /*at_end=*/0);
7450 }
7451
7452 /* The old ARM scoping rules injected variables declared in the
7453    initialization statement of a for-statement into the surrounding
7454    scope.  We support this usage, in order to be backward-compatible.
7455    DECL is a just-declared VAR_DECL; if necessary inject its
7456    declaration into the surrounding scope.  */
7457
7458 void
7459 maybe_inject_for_scope_var (decl)
7460      tree decl;
7461 {
7462   if (current_binding_level->is_for_scope)
7463     {
7464       struct binding_level *outer
7465         = current_binding_level->level_chain;
7466
7467       /* Check to see if the same name is already bound at the outer
7468          level, either because it was directly declared, or because a
7469          dead for-decl got preserved.  In either case, the code would
7470          not have been valid under the ARM scope rules, so clear
7471          is_for_scope for the current_binding_level.
7472
7473          Otherwise, we need to preserve the temp slot for decl to last
7474          into the outer binding level.  */
7475
7476       tree outer_binding
7477         = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
7478
7479       if (outer_binding && BINDING_LEVEL (outer_binding) == outer
7480           && (TREE_CODE (BINDING_VALUE (outer_binding))
7481               == VAR_DECL)
7482           && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
7483         {
7484           BINDING_VALUE (outer_binding)
7485             = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
7486           current_binding_level->is_for_scope = 0;
7487         }
7488       else if (DECL_IN_MEMORY_P (decl))
7489         preserve_temp_slots (DECL_RTL (decl));
7490     }
7491 }
7492
7493 /* Generate code to initialize DECL (a local variable).  */
7494
7495 void
7496 initialize_local_var (decl, init, flags)
7497      tree decl;
7498      tree init;
7499      int flags;
7500 {
7501   tree type = TREE_TYPE (decl);
7502
7503   /* If the type is bogus, don't bother initializing the variable.  */
7504   if (type == error_mark_node)
7505     return;
7506
7507   if (DECL_SIZE (decl) == NULL_TREE && !TREE_STATIC (decl))
7508     {
7509       /* If we used it already as memory, it must stay in memory.  */
7510       DECL_INITIAL (decl) = NULL_TREE;
7511       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
7512     }
7513
7514   /* Local statics are handled differently from ordinary automatic
7515      variables.  */
7516   if (TREE_STATIC (decl))
7517     {
7518       if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7519           || TYPE_NEEDS_DESTRUCTOR (type))
7520         expand_static_init (decl, init);
7521       return;
7522     }
7523
7524   if (DECL_SIZE (decl) && type != error_mark_node)
7525     {
7526       int already_used;
7527
7528       /* Compute and store the initial value.  */
7529       already_used = TREE_USED (decl) || TREE_USED (type);
7530
7531       if (init || TYPE_NEEDS_CONSTRUCTING (type))
7532         {
7533           int saved_stmts_are_full_exprs_p;
7534
7535           emit_line_note (DECL_SOURCE_FILE (decl),
7536                           DECL_SOURCE_LINE (decl));
7537           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p;
7538           stmts_are_full_exprs_p = 1;
7539           finish_expr_stmt (build_aggr_init (decl, init, flags));
7540           stmts_are_full_exprs_p = saved_stmts_are_full_exprs_p;
7541         }
7542
7543       /* Set this to 0 so we can tell whether an aggregate which was
7544          initialized was ever used.  Don't do this if it has a
7545          destructor, so we don't complain about the 'resource
7546          allocation is initialization' idiom.  Now set
7547          attribute((unused)) on types so decls of that type will be
7548          marked used. (see TREE_USED, above.)  */
7549       if (TYPE_NEEDS_CONSTRUCTING (type)
7550           && ! already_used
7551           && !TYPE_NEEDS_DESTRUCTOR (type)
7552           && DECL_NAME (decl))
7553         TREE_USED (decl) = 0;
7554       else if (already_used)
7555         TREE_USED (decl) = 1;
7556     }
7557 }
7558
7559 /* Generate code to destroy DECL (a local variable).  */
7560
7561 static void
7562 destroy_local_var (decl)
7563      tree decl;
7564 {
7565   tree type = TREE_TYPE (decl);
7566   tree cleanup;
7567
7568   /* Only variables get cleaned up.  */
7569   if (TREE_CODE (decl) != VAR_DECL)
7570     return;
7571
7572   /* And only things with destructors need cleaning up.  */
7573   if (!TYPE_NEEDS_DESTRUCTOR (type))
7574     return;
7575
7576   if (TREE_CODE (decl) == VAR_DECL &&
7577       (DECL_EXTERNAL (decl) || TREE_STATIC (decl)))
7578     /* We don't clean up things that aren't defined in this
7579        translation unit, or that need a static cleanup.  The latter
7580        are handled by finish_file.  */
7581     return;
7582
7583   /* Compute the cleanup.  */
7584   cleanup = maybe_build_cleanup (decl);
7585
7586   /* Record the cleanup required for this declaration.  */
7587   if (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node
7588       && cleanup)
7589     finish_decl_cleanup (decl, cleanup);
7590 }
7591
7592 /* Let the back-end know about DECL.  */
7593
7594 void
7595 emit_local_var (decl)
7596      tree decl;
7597 {
7598   /* Create RTL for this variable.  */
7599   if (DECL_RTL (decl))
7600     /* Only a RESULT_DECL should have non-NULL RTL when arriving here.
7601        All other local variables are assigned RTL in this function.  */
7602     my_friendly_assert (TREE_CODE (decl) == RESULT_DECL,
7603                         19990828);
7604   else
7605     {
7606       if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
7607         /* The user must have specified an assembler name for this
7608            variable.  Set that up now.  */
7609         rest_of_decl_compilation
7610           (decl, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
7611            /*top_level=*/0, /*at_end=*/0);
7612       else
7613         expand_decl (decl);
7614     }
7615
7616   /* Actually do the initialization.  */
7617   expand_start_target_temps ();
7618   expand_decl_init (decl);
7619   expand_end_target_temps ();
7620 }
7621
7622 /* Finish processing of a declaration;
7623    install its line number and initial value.
7624    If the length of an array type is not known before,
7625    it must be determined now, from the initial value, or it is an error.
7626
7627    For C++, `cp_finish_decl' must be fairly evasive:  it must keep initializers
7628    for aggregates that have constructors alive on the permanent obstack,
7629    so that the global initializing functions can be written at the end.
7630
7631    INIT0 holds the value of an initializer that should be allowed to escape
7632    the normal rules.
7633
7634    FLAGS is LOOKUP_ONLYCONVERTING is the = init syntax was used, else 0
7635    if the (init) syntax was used.
7636
7637    For functions that take default parameters, DECL points to its
7638    "maximal" instantiation.  `cp_finish_decl' must then also declared its
7639    subsequently lower and lower forms of instantiation, checking for
7640    ambiguity as it goes.  This can be sped up later.  */
7641
7642 void
7643 cp_finish_decl (decl, init, asmspec_tree, flags)
7644      tree decl, init;
7645      tree asmspec_tree;
7646      int flags;
7647 {
7648   register tree type;
7649   tree ttype = NULL_TREE;
7650   const char *asmspec = NULL;
7651   int was_readonly = 0;
7652
7653   /* If this is 0, then we did not change obstacks.  */
7654   if (! decl)
7655     {
7656       if (init)
7657         error ("assignment (not initialization) in declaration");
7658       return;
7659     }
7660
7661   /* Handling __FUNCTION__ and its ilk in a template-function requires
7662      some special processing because we are called from
7663      language-independent code.  */
7664   if (cfun && processing_template_decl
7665       && current_function_name_declared == 2)
7666     {
7667       /* Since we're in a template function, we need to
7668          push_template_decl.  The language-independent code in
7669          declare_hidden_char_array doesn't know to do this.  */
7670       retrofit_lang_decl (decl);
7671       decl = push_template_decl (decl);
7672
7673       if (strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)),
7674                   "__PRETTY_FUNCTION__") == 0)
7675         {
7676           init = build (FUNCTION_NAME, const_string_type_node);
7677           DECL_PRETTY_FUNCTION_P (decl) = 1;
7678         }
7679     }
7680
7681   /* If a name was specified, get the string.  */
7682   if (asmspec_tree)
7683       asmspec = TREE_STRING_POINTER (asmspec_tree);
7684
7685   if (init && TREE_CODE (init) == NAMESPACE_DECL)
7686     {
7687       cp_error ("Cannot initialize `%D' to namespace `%D'",
7688                 decl, init);
7689       init = NULL_TREE;
7690     }
7691
7692   if (current_class_type
7693       && DECL_REAL_CONTEXT (decl) == current_class_type
7694       && TYPE_BEING_DEFINED (current_class_type)
7695       && (DECL_INITIAL (decl) || init))
7696     DECL_DEFINED_IN_CLASS_P (decl) = 1;
7697
7698   if (TREE_CODE (decl) == VAR_DECL
7699       && DECL_CONTEXT (decl)
7700       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
7701       && DECL_CONTEXT (decl) != current_namespace
7702       && init)
7703     {
7704       /* Leave the namespace of the object. */
7705       pop_decl_namespace ();
7706     }
7707
7708   type = TREE_TYPE (decl);
7709
7710   if (type == error_mark_node)
7711     return;
7712
7713   /* Add this declaration to the statement-tree.  */
7714   if (building_stmt_tree () && at_function_scope_p ())
7715     add_decl_stmt (decl);
7716
7717   if (TYPE_HAS_MUTABLE_P (type))
7718     TREE_READONLY (decl) = 0;
7719
7720   if (processing_template_decl)
7721     {
7722       if (init && DECL_INITIAL (decl))
7723         DECL_INITIAL (decl) = init;
7724       goto finish_end0;
7725     }
7726
7727   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
7728   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
7729
7730   /* Take care of TYPE_DECLs up front.  */
7731   if (TREE_CODE (decl) == TYPE_DECL)
7732     {
7733       if (init && DECL_INITIAL (decl))
7734         {
7735           /* typedef foo = bar; store the type of bar as the type of foo.  */
7736           TREE_TYPE (decl) = type = TREE_TYPE (init);
7737           DECL_INITIAL (decl) = init = NULL_TREE;
7738         }
7739       if (type != error_mark_node
7740           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
7741         {
7742           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
7743             cp_warning ("shadowing previous type declaration of `%#D'", decl);
7744           set_identifier_type_value (DECL_NAME (decl), type);
7745           CLASSTYPE_GOT_SEMICOLON (type) = 1;
7746         }
7747       GNU_xref_decl (current_function_decl, decl);
7748
7749       /* If we have installed this as the canonical typedef for this
7750          type, and that type has not been defined yet, delay emitting
7751          the debug information for it, as we will emit it later.  */
7752       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
7753           && TYPE_SIZE (TREE_TYPE (decl)) == NULL_TREE)
7754         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
7755
7756       rest_of_decl_compilation (decl, NULL_PTR,
7757                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
7758       goto finish_end;
7759     }
7760
7761   if (TREE_CODE (decl) != FUNCTION_DECL)
7762     ttype = target_type (type);
7763
7764   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
7765       && TYPE_NEEDS_CONSTRUCTING (type))
7766     {
7767       /* Currently, GNU C++ puts constants in text space, making them
7768          impossible to initialize.  In the future, one would hope for
7769          an operating system which understood the difference between
7770          initialization and the running of a program.  */
7771       was_readonly = 1;
7772       TREE_READONLY (decl) = 0;
7773     }
7774
7775   if (TREE_CODE (decl) == FIELD_DECL && asmspec)
7776     {
7777       /* This must override the asm specifier which was placed by
7778          grokclassfn.  Lay this out fresh.  */
7779       DECL_RTL (TREE_TYPE (decl)) = NULL_RTX;
7780       DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
7781       make_decl_rtl (decl, asmspec, 0);
7782     }
7783
7784   /* Deduce size of array from initialization, if not already known.  */
7785   maybe_deduce_size_from_array_init (decl, init);
7786   init = check_initializer (decl, init);
7787
7788   GNU_xref_decl (current_function_decl, decl);
7789
7790   if (TREE_CODE (decl) == VAR_DECL)
7791     layout_var_decl (decl);
7792
7793   /* Output the assembler code and/or RTL code for variables and functions,
7794      unless the type is an undefined structure or union.
7795      If not, it will get done when the type is completed.  */
7796   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
7797       || TREE_CODE (decl) == RESULT_DECL)
7798     {
7799       if (TREE_CODE (decl) == VAR_DECL)
7800         maybe_commonize_var (decl);
7801
7802       make_rtl_for_nonlocal_decl (decl, init, asmspec);
7803
7804       if (TREE_CODE (type) == FUNCTION_TYPE
7805           || TREE_CODE (type) == METHOD_TYPE)
7806         abstract_virtuals_error (decl,
7807                                  strip_array_types (TREE_TYPE (type)));
7808       else
7809         abstract_virtuals_error (decl, strip_array_types (type));
7810
7811       if (TREE_CODE (decl) == FUNCTION_DECL)
7812         ;
7813       else if (DECL_EXTERNAL (decl)
7814                && ! (DECL_LANG_SPECIFIC (decl)
7815                      && DECL_NOT_REALLY_EXTERN (decl)))
7816         {
7817           if (init)
7818             DECL_INITIAL (decl) = init;
7819         }
7820       else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
7821         {
7822           /* This is a local declaration.  */
7823           if (doing_semantic_analysis_p ())
7824             maybe_inject_for_scope_var (decl);
7825           /* Initialize the local variable.  But, if we're building a
7826              statement-tree, we'll do the initialization when we
7827              expand the tree.  */
7828           if (processing_template_decl)
7829             {
7830               if (init || DECL_INITIAL (decl) == error_mark_node)
7831                 DECL_INITIAL (decl) = init;
7832             }
7833           else
7834             {
7835               /* If we're not building RTL, then we need to do so
7836                  now.  */
7837               if (!building_stmt_tree ())
7838                 emit_local_var (decl);
7839               /* Initialize the variable.  */
7840               initialize_local_var (decl, init, flags);
7841               /* Clean up the variable.  */
7842               destroy_local_var (decl);
7843             }
7844         }
7845       else if (TREE_STATIC (decl) && type != error_mark_node)
7846         {
7847           /* Cleanups for static variables are handled by `finish_file'.  */
7848           if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7849               || TYPE_NEEDS_DESTRUCTOR (type))
7850             expand_static_init (decl, init);
7851         }
7852     finish_end0:
7853
7854       /* Undo call to `pushclass' that was done in `start_decl'
7855          due to initialization of qualified member variable.
7856          I.e., Foo::x = 10;  */
7857       {
7858         tree context = DECL_REAL_CONTEXT (decl);
7859         if (context
7860             && TREE_CODE_CLASS (TREE_CODE (context)) == 't'
7861             && (TREE_CODE (decl) == VAR_DECL
7862                 /* We also have a pushclass done that we need to undo here
7863                    if we're at top level and declare a method.  */
7864                 || TREE_CODE (decl) == FUNCTION_DECL)
7865             /* If size hasn't been set, we're still defining it,
7866                and therefore inside the class body; don't pop
7867                the binding level..  */
7868             && TYPE_SIZE (context) != NULL_TREE
7869             && context == current_class_type)
7870           pop_nested_class ();
7871       }
7872     }
7873
7874  finish_end:
7875
7876   /* If requested, warn about definitions of large data objects.  */
7877
7878   if (warn_larger_than
7879       && ! processing_template_decl
7880       && (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL)
7881       && !DECL_EXTERNAL (decl))
7882     {
7883       register tree decl_size = DECL_SIZE (decl);
7884
7885       if (decl_size && TREE_CODE (decl_size) == INTEGER_CST)
7886         {
7887           unsigned units = TREE_INT_CST_LOW (decl_size) / BITS_PER_UNIT;
7888
7889           if (units > larger_than_size)
7890             warning_with_decl (decl, "size of `%s' is %u bytes", units);
7891         }
7892     }
7893
7894   if (was_readonly)
7895     TREE_READONLY (decl) = 1;
7896 }
7897
7898 /* This is here for a midend callback from c-common.c */
7899
7900 void
7901 finish_decl (decl, init, asmspec_tree)
7902      tree decl, init;
7903      tree asmspec_tree;
7904 {
7905   cp_finish_decl (decl, init, asmspec_tree, 0);
7906 }
7907
7908 /* Returns a declaration for a VAR_DECL as if:
7909
7910      extern "C" TYPE NAME;
7911
7912    had been seen.  Used to create compiler-generated global
7913    variables.  */
7914
7915 tree
7916 declare_global_var (name, type)
7917      tree name;
7918      tree type;
7919 {
7920   tree decl;
7921
7922   push_to_top_level ();
7923   decl = build_decl (VAR_DECL, name, type);
7924   TREE_PUBLIC (decl) = 1;
7925   DECL_EXTERNAL (decl) = 1;
7926   DECL_ARTIFICIAL (decl) = 1;
7927   pushdecl (decl);
7928   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
7929   pop_from_top_level ();
7930
7931   return decl;
7932 }
7933
7934 /* Returns a pointer to the `atexit' function.  Note that if
7935    FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
7936    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
7937
7938 static tree
7939 get_atexit_node ()
7940 {
7941   tree atexit_fndecl;
7942   tree arg_types;
7943   tree fn_type;
7944   tree fn_ptr_type;
7945   const char *name;
7946
7947   if (atexit_node)
7948     return atexit_node;
7949
7950   if (flag_use_cxa_atexit)
7951     {
7952       /* The declaration for `__cxa_atexit' is:
7953
7954            int __cxa_atexit (void (*)(void *), void *, void *)
7955
7956          We build up the argument types and then then function type
7957          itself.  */
7958
7959       /* First, build the pointer-to-function type for the first
7960          argument.  */
7961       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
7962       fn_type = build_function_type (void_type_node, arg_types);
7963       fn_ptr_type = build_pointer_type (fn_type);
7964       /* Then, build the rest of the argument types.  */
7965       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
7966       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
7967       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
7968       /* And the final __cxa_atexit type.  */
7969       fn_type = build_function_type (integer_type_node, arg_types);
7970       fn_ptr_type = build_pointer_type (fn_type);
7971       name = "__cxa_atexit";
7972     }
7973   else
7974     {
7975       /* The declaration for `atexit' is:
7976
7977            int atexit (void (*)());
7978
7979          We build up the argument types and then then function type
7980          itself.  */
7981       fn_type = build_function_type (void_type_node, void_list_node);
7982       fn_ptr_type = build_pointer_type (fn_type);
7983       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
7984       /* Build the final atexit type.  */
7985       fn_type = build_function_type (integer_type_node, arg_types);
7986       name = "atexit";
7987     }
7988
7989   /* Now, build the function declaration.  */
7990   push_lang_context (lang_name_c);
7991   atexit_fndecl = define_function (name, fn_type, /*pfn=*/0, NULL_PTR);
7992   mark_used (atexit_fndecl);
7993   pop_lang_context ();
7994   atexit_node = default_conversion (atexit_fndecl);
7995
7996   return atexit_node;
7997 }
7998
7999 /* Returns the __dso_handle VAR_DECL.  */
8000
8001 static tree
8002 get_dso_handle_node ()
8003 {
8004   if (dso_handle_node)
8005     return dso_handle_node;
8006
8007   /* Declare the variable.  */
8008   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8009                                         ptr_type_node);
8010
8011   return dso_handle_node;
8012 }
8013
8014 /* Begin a new function with internal linkage whose job will be simply
8015    to destroy some particular variable.  */
8016
8017 static tree
8018 start_cleanup_fn ()
8019 {
8020   static int counter = 0;
8021   int old_interface_unknown = interface_unknown;
8022   char name[32];
8023   tree parmtypes;
8024   tree fntype;
8025   tree fndecl;
8026
8027   push_to_top_level ();
8028
8029   /* No need to mangle this.  */
8030   push_lang_context (lang_name_c);
8031
8032   interface_unknown = 1;
8033
8034   /* Build the parameter-types.  */
8035   parmtypes = void_list_node;
8036   /* Functions passed to __cxa_atexit take an additional parameter.
8037      We'll just ignore it.  After we implement the new calling
8038      convention for destructors, we can eliminate the use of
8039      additional cleanup functions entirely in the -fnew-abi case.  */
8040   if (flag_use_cxa_atexit)
8041     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8042   /* Build the function type itself.  */
8043   fntype = build_function_type (void_type_node, parmtypes);
8044   /* Build the name of the function.  */
8045   sprintf (name, "__tcf_%d", counter++);
8046   /* Build the function declaration.  */
8047   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8048   /* It's a function with internal linkage, generated by the
8049      compiler.  */
8050   TREE_PUBLIC (fndecl) = 0;
8051   DECL_ARTIFICIAL (fndecl) = 1;
8052   /* Build the parameter.  */
8053   if (flag_use_cxa_atexit)
8054     {
8055       tree parmdecl;
8056
8057       parmdecl = build_decl (PARM_DECL, NULL_TREE, ptr_type_node);
8058       DECL_CONTEXT (parmdecl) = fndecl;
8059       DECL_ARG_TYPE (parmdecl) = ptr_type_node;
8060       TREE_USED (parmdecl) = 1;
8061       DECL_ARGUMENTS (fndecl) = parmdecl;
8062     }
8063
8064   pushdecl (fndecl);
8065   start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8066   do_pushlevel ();
8067
8068   interface_unknown = old_interface_unknown;
8069
8070   pop_lang_context ();
8071
8072   return current_function_decl;
8073 }
8074
8075 /* Finish the cleanup function begun by start_cleanup_fn.  */
8076
8077 static void
8078 end_cleanup_fn ()
8079 {
8080   do_poplevel ();
8081
8082   expand_body (finish_function (lineno, 0));
8083
8084   pop_from_top_level ();
8085 }
8086
8087 /* Generate code to handle the destruction of DECL, an object with
8088    static storage duration.  */
8089
8090 void
8091 register_dtor_fn (decl)
8092      tree decl;
8093 {
8094   tree cleanup;
8095   tree compound_stmt;
8096   tree args;
8097   tree fcall;
8098
8099   int saved_flag_access_control;
8100
8101   if (!TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (decl)))
8102     return;
8103
8104   /* Call build_cleanup before we enter the anonymous function so that
8105      any access checks will be done relative to the current scope,
8106      rather than the scope of the anonymous function.  */
8107   build_cleanup (decl);
8108
8109   /* Now start the function.  */
8110   cleanup = start_cleanup_fn ();
8111
8112   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
8113      to the original function, rather than the anonymous one.  That
8114      will make the back-end think that nested functions are in use,
8115      which causes confusion.  */
8116   saved_flag_access_control = flag_access_control;
8117   flag_access_control = 0;
8118   fcall = build_cleanup (decl);
8119   flag_access_control = saved_flag_access_control;
8120
8121   /* Create the body of the anonymous function.  */
8122   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8123   finish_expr_stmt (fcall);
8124   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8125   end_cleanup_fn ();
8126
8127   /* Call atexit with the cleanup function.  */
8128   mark_addressable (cleanup);
8129   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8130   if (flag_use_cxa_atexit)
8131     {
8132       args = tree_cons (NULL_TREE, get_dso_handle_node (), NULL_TREE);
8133       args = tree_cons (NULL_TREE, null_pointer_node, args);
8134       args = tree_cons (NULL_TREE, cleanup, args);
8135     }
8136   else
8137     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8138   finish_expr_stmt (build_function_call (get_atexit_node (), args));
8139 }
8140
8141 void
8142 expand_static_init (decl, init)
8143      tree decl;
8144      tree init;
8145 {
8146   tree oldstatic = value_member (decl, static_aggregates);
8147
8148   if (oldstatic)
8149     {
8150       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8151         cp_error ("multiple initializations given for `%D'", decl);
8152     }
8153   else if (! toplevel_bindings_p ())
8154     {
8155       /* Emit code to perform this initialization but once.  */
8156       tree temp;
8157       tree if_stmt;
8158       tree then_clause;
8159       tree assignment;
8160       tree temp_init;
8161
8162       /* Emit code to perform this initialization but once.  This code
8163          looks like:
8164
8165            static int temp = 0;
8166            if (!temp) {
8167              // Do initialization.
8168              temp = 1;
8169              // Register variable for destruction at end of program.
8170            }
8171
8172          Note that the `temp' variable is only set to 1 *after* the
8173          initialization is complete.  This ensures that an exception,
8174          thrown during the construction, will cause the variable to
8175          reinitialized when we pass through this code again, as per:
8176
8177            [stmt.dcl]
8178
8179            If the initialization exits by throwing an exception, the
8180            initialization is not complete, so it will be tried again
8181            the next time control enters the declaration.
8182
8183          In theory, this process should be thread-safe, too; multiple
8184          threads should not be able to initialize the variable more
8185          than once.  We don't yet attempt to ensure thread-safety.  */
8186       temp = get_temp_name (integer_type_node, 1);
8187       rest_of_decl_compilation (temp, NULL_PTR, 0, 0);
8188
8189       /* Begin the conditional initialization.  */
8190       if_stmt = begin_if_stmt ();
8191       finish_if_stmt_cond (build_binary_op (EQ_EXPR, temp,
8192                                             integer_zero_node),
8193                            if_stmt);
8194       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8195
8196       /* Do the initialization itself.  */
8197       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8198           || (init && TREE_CODE (init) == TREE_LIST))
8199         assignment = build_aggr_init (decl, init, 0);
8200       else if (init)
8201         /* The initialization we're doing here is just a bitwise
8202            copy.  */
8203         assignment = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
8204       else
8205         assignment = NULL_TREE;
8206
8207       /* Once the assignment is complete, set TEMP to 1.  Since the
8208          construction of the static object is complete at this point,
8209          we want to make sure TEMP is set to 1 even if a temporary
8210          constructed during the initialization throws an exception
8211          when it is destroyed.  So, we combine the initialization and
8212          the assignment to TEMP into a single expression, ensuring
8213          that when we call finish_expr_stmt the cleanups will not be
8214          run until after TEMP is set to 1.  */
8215       temp_init = build_modify_expr (temp, NOP_EXPR, integer_one_node);
8216       if (assignment)
8217         {
8218           assignment = tree_cons (NULL_TREE, assignment,
8219                                   build_tree_list (NULL_TREE,
8220                                                    temp_init));
8221           assignment = build_compound_expr (assignment);
8222         }
8223       else
8224         assignment = temp_init;
8225       finish_expr_stmt (assignment);
8226
8227       /* Use atexit to register a function for destroying this static
8228          variable.  */
8229       register_dtor_fn (decl);
8230
8231       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8232       finish_then_clause (if_stmt);
8233       finish_if_stmt ();
8234     }
8235   else
8236     static_aggregates = tree_cons (init, decl, static_aggregates);
8237 }
8238
8239 /* Finish the declaration of a catch-parameter.  */
8240
8241 tree
8242 start_handler_parms (declspecs, declarator)
8243      tree declspecs;
8244      tree declarator;
8245 {
8246   tree decl;
8247   if (declspecs)
8248     {
8249       decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8250                              1, NULL_TREE);
8251       if (decl == NULL_TREE)
8252         error ("invalid catch parameter");
8253     }
8254   else
8255     decl = NULL_TREE;
8256
8257   return decl;
8258 }
8259
8260 \f
8261 /* Make TYPE a complete type based on INITIAL_VALUE.
8262    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8263    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
8264
8265 int
8266 complete_array_type (type, initial_value, do_default)
8267      tree type, initial_value;
8268      int do_default;
8269 {
8270   register tree maxindex = NULL_TREE;
8271   int value = 0;
8272
8273   if (initial_value)
8274     {
8275       /* Note MAXINDEX  is really the maximum index,
8276          one less than the size.  */
8277       if (TREE_CODE (initial_value) == STRING_CST)
8278         {
8279           int eltsize
8280             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8281           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8282                                    / eltsize) - 1, 0);
8283         }
8284       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8285         {
8286           tree elts = CONSTRUCTOR_ELTS (initial_value);
8287           maxindex = size_binop (MINUS_EXPR, integer_zero_node, size_one_node);
8288           for (; elts; elts = TREE_CHAIN (elts))
8289             {
8290               if (TREE_PURPOSE (elts))
8291                 maxindex = TREE_PURPOSE (elts);
8292               else
8293                 maxindex = size_binop (PLUS_EXPR, maxindex, size_one_node);
8294             }
8295           maxindex = copy_node (maxindex);
8296         }
8297       else
8298         {
8299           /* Make an error message unless that happened already.  */
8300           if (initial_value != error_mark_node)
8301             value = 1;
8302           else
8303             initial_value = NULL_TREE;
8304
8305           /* Prevent further error messages.  */
8306           maxindex = build_int_2 (0, 0);
8307         }
8308     }
8309
8310   if (!maxindex)
8311     {
8312       if (do_default)
8313         maxindex = build_int_2 (0, 0);
8314       value = 2;
8315     }
8316
8317   if (maxindex)
8318     {
8319       tree itype;
8320       tree domain;
8321
8322       domain = build_index_type (maxindex);
8323       TYPE_DOMAIN (type) = domain;
8324
8325       if (! TREE_TYPE (maxindex))
8326         TREE_TYPE (maxindex) = domain;
8327       if (initial_value)
8328         itype = TREE_TYPE (initial_value);
8329       else
8330         itype = NULL;
8331       if (itype && !TYPE_DOMAIN (itype))
8332         TYPE_DOMAIN (itype) = domain;
8333       /* The type of the main variant should never be used for arrays
8334          of different sizes.  It should only ever be completed with the
8335          size of the array.  */
8336       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8337         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8338     }
8339
8340   /* Lay out the type now that we can get the real answer.  */
8341
8342   layout_type (type);
8343
8344   return value;
8345 }
8346 \f
8347 /* Return zero if something is declared to be a member of type
8348    CTYPE when in the context of CUR_TYPE.  STRING is the error
8349    message to print in that case.  Otherwise, quietly return 1.  */
8350
8351 static int
8352 member_function_or_else (ctype, cur_type, flags)
8353      tree ctype, cur_type;
8354      enum overload_flags flags;
8355 {
8356   if (ctype && ctype != cur_type)
8357     {
8358       if (flags == DTOR_FLAG)
8359         error ("destructor for alien class `%s' cannot be a member",
8360                TYPE_NAME_STRING (ctype));
8361       else
8362         error ("constructor for alien class `%s' cannot be a member",
8363                TYPE_NAME_STRING (ctype));
8364       return 0;
8365     }
8366   return 1;
8367 }
8368 \f
8369 /* Subroutine of `grokdeclarator'.  */
8370
8371 /* Generate errors possibly applicable for a given set of specifiers.
8372    This is for ARM $7.1.2.  */
8373
8374 static void
8375 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8376      tree object;
8377      const char *type;
8378      int virtualp, quals, friendp, raises, inlinep;
8379 {
8380   if (virtualp)
8381     cp_error ("`%D' declared as a `virtual' %s", object, type);
8382   if (inlinep)
8383     cp_error ("`%D' declared as an `inline' %s", object, type);
8384   if (quals)
8385     cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8386               object, type);
8387   if (friendp)
8388     cp_error_at ("`%D' declared as a friend", object);
8389   if (raises)
8390     cp_error_at ("`%D' declared with an exception specification", object);
8391 }
8392
8393 /* CTYPE is class type, or null if non-class.
8394    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8395    or METHOD_TYPE.
8396    DECLARATOR is the function's name.
8397    VIRTUALP is truthvalue of whether the function is virtual or not.
8398    FLAGS are to be passed through to `grokclassfn'.
8399    QUALS are qualifiers indicating whether the function is `const'
8400    or `volatile'.
8401    RAISES is a list of exceptions that this function can raise.
8402    CHECK is 1 if we must find this method in CTYPE, 0 if we should
8403    not look, and -1 if we should not call `grokclassfn' at all.
8404
8405    Returns `NULL_TREE' if something goes wrong, after issuing
8406    applicable error messages.  */
8407
8408 static tree
8409 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8410             raises, check, friendp, publicp, inlinep, funcdef_flag,
8411             template_count, in_namespace)
8412      tree ctype, type;
8413      tree declarator;
8414      tree orig_declarator;
8415      int virtualp;
8416      enum overload_flags flags;
8417      tree quals, raises;
8418      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8419      tree in_namespace;
8420 {
8421   tree cname, decl;
8422   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8423   int has_default_arg = 0;
8424   tree t;
8425
8426   if (ctype)
8427     cname = TREE_CODE (TYPE_NAME (ctype)) == TYPE_DECL
8428       ? TYPE_IDENTIFIER (ctype) : TYPE_NAME (ctype);
8429   else
8430     cname = NULL_TREE;
8431
8432   if (raises)
8433     {
8434       type = build_exception_variant (type, raises);
8435     }
8436
8437   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8438   /* Propagate volatile out from type to decl. */
8439   if (TYPE_VOLATILE (type))
8440     TREE_THIS_VOLATILE (decl) = 1;
8441
8442   /* If this decl has namespace scope, set that up.  */
8443   if (in_namespace)
8444     set_decl_namespace (decl, in_namespace, friendp);
8445   else if (publicp && ! ctype)
8446     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8447
8448   /* `main' and builtins have implicit 'C' linkage.  */
8449   if ((MAIN_NAME_P (declarator)
8450        || (IDENTIFIER_LENGTH (declarator) > 10
8451            && IDENTIFIER_POINTER (declarator)[0] == '_'
8452            && IDENTIFIER_POINTER (declarator)[1] == '_'
8453            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8454       && current_lang_name == lang_name_cplusplus
8455       && ctype == NULL_TREE
8456       /* NULL_TREE means global namespace.  */
8457       && DECL_CONTEXT (decl) == NULL_TREE)
8458     DECL_LANGUAGE (decl) = lang_c;
8459
8460   /* Should probably propagate const out from type to decl I bet (mrs).  */
8461   if (staticp)
8462     {
8463       DECL_STATIC_FUNCTION_P (decl) = 1;
8464       DECL_CONTEXT (decl) = ctype;
8465     }
8466
8467   if (ctype)
8468     DECL_CLASS_CONTEXT (decl) = ctype;
8469
8470   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8471     {
8472       if (processing_template_decl)
8473         error ("cannot declare `main' to be a template");
8474       if (inlinep)
8475         error ("cannot declare `main' to be inline");
8476       else if (! publicp)
8477         error ("cannot declare `main' to be static");
8478       inlinep = 0;
8479       publicp = 1;
8480     }
8481
8482   /* Members of anonymous types and local classes have no linkage; make
8483      them internal.  */
8484   if (ctype && (ANON_AGGRNAME_P (TYPE_IDENTIFIER (ctype))
8485                 || hack_decl_function_context (TYPE_MAIN_DECL (ctype))))
8486     publicp = 0;
8487
8488   if (publicp)
8489     {
8490       /* [basic.link]: A name with no linkage (notably, the name of a class
8491          or enumeration declared in a local scope) shall not be used to
8492          declare an entity with linkage.
8493
8494          Only check this for public decls for now.  */
8495       t = no_linkage_check (TREE_TYPE (decl));
8496       if (t)
8497         {
8498           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8499             {
8500               if (DECL_LANGUAGE (decl) == lang_c)
8501                 /* Allow this; it's pretty common in C.  */;
8502               else
8503                 cp_pedwarn ("non-local function `%#D' uses anonymous type",
8504                             decl);
8505             }
8506           else
8507             cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8508                         decl, t);
8509         }
8510     }
8511
8512   TREE_PUBLIC (decl) = publicp;
8513   if (! publicp)
8514     {
8515       DECL_INTERFACE_KNOWN (decl) = 1;
8516       DECL_NOT_REALLY_EXTERN (decl) = 1;
8517     }
8518
8519   if (inlinep)
8520     DECL_THIS_INLINE (decl) = DECL_INLINE (decl) = 1;
8521
8522   DECL_EXTERNAL (decl) = 1;
8523   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
8524     {
8525       cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8526                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
8527       quals = NULL_TREE;
8528     }
8529
8530   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
8531     grok_op_properties (decl, virtualp, check < 0);
8532
8533   if (ctype && hack_decl_function_context (decl))
8534     DECL_NO_STATIC_CHAIN (decl) = 1;
8535
8536   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
8537     if (TREE_PURPOSE (t)
8538         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
8539       {
8540         has_default_arg = 1;
8541         break;
8542       }
8543
8544   if (friendp
8545       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
8546     {
8547       if (funcdef_flag)
8548         cp_error
8549           ("defining explicit specialization `%D' in friend declaration",
8550            orig_declarator);
8551       else
8552         {
8553           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8554             {
8555               /* Something like `template <class T> friend void f<T>()'.  */
8556               cp_error ("template-id `%D' in declaration of primary template",
8557                         orig_declarator);
8558               return NULL_TREE;
8559             }
8560
8561
8562           /* A friend declaration of the form friend void f<>().  Record
8563              the information in the TEMPLATE_ID_EXPR.  */
8564           SET_DECL_IMPLICIT_INSTANTIATION (decl);
8565           DECL_TEMPLATE_INFO (decl)
8566             = tree_cons (TREE_OPERAND (orig_declarator, 0),
8567                          TREE_OPERAND (orig_declarator, 1),
8568                          NULL_TREE);
8569
8570           if (has_default_arg)
8571             {
8572               cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8573                         decl);
8574               return NULL_TREE;
8575             }
8576
8577           if (inlinep)
8578             {
8579               cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
8580                         decl);
8581               return NULL_TREE;
8582             }
8583         }
8584     }
8585
8586   if (has_default_arg)
8587     add_defarg_fn (decl);
8588
8589   /* Plain overloading: will not be grok'd by grokclassfn.  */
8590   if (! ctype && ! processing_template_decl
8591       && DECL_LANGUAGE (decl) != lang_c
8592       && (! DECL_USE_TEMPLATE (decl) || name_mangling_version < 1))
8593     set_mangled_name_for_decl (decl);
8594
8595   if (funcdef_flag)
8596     /* Make the init_value nonzero so pushdecl knows this is not
8597        tentative.  error_mark_node is replaced later with the BLOCK.  */
8598     DECL_INITIAL (decl) = error_mark_node;
8599
8600   /* Caller will do the rest of this.  */
8601   if (check < 0)
8602     return decl;
8603
8604   if (flags == NO_SPECIAL && ctype && constructor_name (cname) == declarator)
8605     {
8606       tree tmp;
8607       /* Just handle constructors here.  We could do this
8608          inside the following if stmt, but I think
8609          that the code is more legible by breaking this
8610          case out.  See comments below for what each of
8611          the following calls is supposed to do.  */
8612       DECL_CONSTRUCTOR_P (decl) = 1;
8613
8614       grokclassfn (ctype, decl, flags, quals);
8615
8616       decl = check_explicit_specialization (orig_declarator, decl,
8617                                             template_count,
8618                                             2 * (funcdef_flag != 0) +
8619                                             4 * (friendp != 0));
8620       if (decl == error_mark_node)
8621         return NULL_TREE;
8622
8623       if ((! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
8624           && check)
8625         {
8626           tmp = check_classfn (ctype, decl);
8627
8628           if (tmp && TREE_CODE (tmp) == TEMPLATE_DECL)
8629             tmp = DECL_TEMPLATE_RESULT(tmp);
8630
8631           if (tmp && DECL_ARTIFICIAL (tmp))
8632             cp_error ("definition of implicitly-declared `%D'", tmp);
8633           if (tmp && duplicate_decls (decl, tmp))
8634             return tmp;
8635         }
8636       if (! grok_ctor_properties (ctype, decl))
8637         return NULL_TREE;
8638     }
8639   else
8640     {
8641       tree tmp;
8642
8643       /* Function gets the ugly name, field gets the nice one.
8644          This call may change the type of the function (because
8645          of default parameters)!  */
8646       if (ctype != NULL_TREE)
8647         grokclassfn (ctype, decl, flags, quals);
8648
8649       decl = check_explicit_specialization (orig_declarator, decl,
8650                                             template_count,
8651                                             2 * (funcdef_flag != 0) +
8652                                             4 * (friendp != 0));
8653       if (decl == error_mark_node)
8654         return NULL_TREE;
8655
8656       if (ctype != NULL_TREE
8657           && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
8658           && check)
8659         {
8660           tmp = check_classfn (ctype, decl);
8661
8662           if (tmp && TREE_CODE (tmp) == TEMPLATE_DECL)
8663             tmp = DECL_TEMPLATE_RESULT (tmp);
8664
8665           if (tmp && DECL_STATIC_FUNCTION_P (tmp)
8666               && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
8667             {
8668               /* Remove the `this' parm added by grokclassfn.
8669                  XXX Isn't this done in start_function, too?  */
8670               revert_static_member_fn (&decl, NULL, NULL);
8671               last_function_parms = TREE_CHAIN (last_function_parms);
8672             }
8673           if (tmp && DECL_ARTIFICIAL (tmp))
8674             cp_error ("definition of implicitly-declared `%D'", tmp);
8675           if (tmp)
8676             {
8677               /* Attempt to merge the declarations.  This can fail, in
8678                  the case of some illegal specialization declarations.  */
8679               if (!duplicate_decls (decl, tmp))
8680                 cp_error ("no `%#D' member function declared in class `%T'",
8681                           decl, ctype);
8682               return tmp;
8683             }
8684         }
8685
8686       if (ctype == NULL_TREE || check)
8687         return decl;
8688
8689       if (virtualp)
8690         {
8691           DECL_VIRTUAL_P (decl) = 1;
8692           if (DECL_VINDEX (decl) == NULL_TREE)
8693             DECL_VINDEX (decl) = error_mark_node;
8694           IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
8695         }
8696     }
8697   return decl;
8698 }
8699
8700 static tree
8701 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
8702      tree type;
8703      tree declarator;
8704      RID_BIT_TYPE *specbits_in;
8705      int initialized;
8706      int constp;
8707      tree in_namespace;
8708 {
8709   tree decl;
8710   RID_BIT_TYPE specbits;
8711
8712   specbits = *specbits_in;
8713
8714   if (TREE_CODE (type) == OFFSET_TYPE)
8715     {
8716       /* If you declare a static member so that it
8717          can be initialized, the code will reach here.  */
8718       tree basetype = TYPE_OFFSET_BASETYPE (type);
8719       type = TREE_TYPE (type);
8720       decl = build_lang_decl (VAR_DECL, declarator, type);
8721       DECL_CONTEXT (decl) = basetype;
8722       DECL_CLASS_CONTEXT (decl) = basetype;
8723       DECL_ASSEMBLER_NAME (decl) = build_static_name (basetype, declarator);
8724     }
8725   else
8726     {
8727       tree context;
8728
8729       if (in_namespace)
8730         context = in_namespace;
8731       else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
8732         context = current_namespace;
8733       else
8734         context = NULL_TREE;
8735
8736       if (processing_template_decl)
8737         /* If we're in a template, we need DECL_LANG_SPECIFIC so that
8738            we can call push_template_decl.  */
8739         decl = build_lang_decl (VAR_DECL, declarator, type);
8740       else
8741         decl = build_decl (VAR_DECL, declarator, type);
8742
8743       if (context)
8744         set_decl_namespace (decl, context, 0);
8745
8746       context = DECL_CONTEXT (decl);
8747       if (declarator && context && current_lang_name != lang_name_c)
8748         DECL_ASSEMBLER_NAME (decl) = build_static_name (context, declarator);
8749     }
8750
8751   if (in_namespace)
8752     set_decl_namespace (decl, in_namespace, 0);
8753
8754   if (RIDBIT_SETP (RID_EXTERN, specbits))
8755     {
8756       DECL_THIS_EXTERN (decl) = 1;
8757       DECL_EXTERNAL (decl) = !initialized;
8758     }
8759
8760   /* In class context, static means one per class,
8761      public access, and static storage.  */
8762   if (DECL_CLASS_SCOPE_P (decl))
8763     {
8764       TREE_PUBLIC (decl) = 1;
8765       TREE_STATIC (decl) = 1;
8766       DECL_EXTERNAL (decl) = 0;
8767     }
8768   /* At top level, either `static' or no s.c. makes a definition
8769      (perhaps tentative), and absence of `static' makes it public.  */
8770   else if (toplevel_bindings_p ())
8771     {
8772       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
8773                             && (DECL_THIS_EXTERN (decl) || ! constp));
8774       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
8775     }
8776   /* Not at top level, only `static' makes a static definition.  */
8777   else
8778     {
8779       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
8780       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
8781     }
8782
8783   if (TREE_PUBLIC (decl))
8784     {
8785       /* [basic.link]: A name with no linkage (notably, the name of a class
8786          or enumeration declared in a local scope) shall not be used to
8787          declare an entity with linkage.
8788
8789          Only check this for public decls for now.  */
8790       tree t = no_linkage_check (TREE_TYPE (decl));
8791       if (t)
8792         {
8793           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8794             /* Ignore for now; `enum { foo } e' is pretty common.  */;
8795           else
8796             cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
8797                         decl, t);
8798         }
8799     }
8800
8801   return decl;
8802 }
8803
8804 /* Create and return a canonical pointer to member function type, for
8805    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
8806
8807 tree
8808 build_ptrmemfunc_type (type)
8809      tree type;
8810 {
8811   tree fields[4];
8812   tree t;
8813   tree u;
8814   tree unqualified_variant = NULL_TREE;
8815
8816   /* If a canonical type already exists for this type, use it.  We use
8817      this method instead of type_hash_canon, because it only does a
8818      simple equality check on the list of field members.  */
8819
8820   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
8821     return t;
8822
8823   /* Make sure that we always have the unqualified pointer-to-member
8824      type first.  */
8825   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
8826     unqualified_variant
8827       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
8828
8829   u = make_aggr_type (UNION_TYPE);
8830   SET_IS_AGGR_TYPE (u, 0);
8831   fields[0] = build_lang_decl (FIELD_DECL, pfn_identifier, type);
8832   fields[1] = build_lang_decl (FIELD_DECL, delta2_identifier,
8833                                delta_type_node);
8834   finish_builtin_type (u, "__ptrmemfunc_type", fields, 1, ptr_type_node);
8835   TYPE_NAME (u) = NULL_TREE;
8836
8837   t = make_aggr_type (RECORD_TYPE);
8838
8839   /* Let the front-end know this is a pointer to member function...  */
8840   TYPE_PTRMEMFUNC_FLAG (t) = 1;
8841   /* ... and not really an aggregate.  */
8842   SET_IS_AGGR_TYPE (t, 0);
8843
8844   fields[0] = build_lang_decl (FIELD_DECL, delta_identifier,
8845                                delta_type_node);
8846   fields[1] = build_lang_decl (FIELD_DECL, index_identifier,
8847                                delta_type_node);
8848   fields[2] = build_lang_decl (FIELD_DECL, pfn_or_delta2_identifier, u);
8849   finish_builtin_type (t, "__ptrmemfunc_type", fields, 2, ptr_type_node);
8850
8851   /* Zap out the name so that the back-end will give us the debugging
8852      information for this anonymous RECORD_TYPE.  */
8853   TYPE_NAME (t) = NULL_TREE;
8854
8855   /* If this is not the unqualified form of this pointer-to-member
8856      type, set the TYPE_MAIN_VARIANT for this type to be the
8857      unqualified type.  Since they are actually RECORD_TYPEs that are
8858      not variants of each other, we must do this manually.  */
8859   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
8860     {
8861       t = build_qualified_type (t, CP_TYPE_QUALS (type));
8862       TYPE_MAIN_VARIANT (t) = unqualified_variant;
8863       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
8864       TYPE_NEXT_VARIANT (unqualified_variant) = t;
8865     }
8866
8867   /* Cache this pointer-to-member type so that we can find it again
8868      later.  */
8869   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
8870
8871   /* Seems to be wanted.  */
8872   CLASSTYPE_GOT_SEMICOLON (t) = 1;
8873
8874   return t;
8875 }
8876
8877 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
8878    Check to see that the definition is valid.  Issue appropriate error
8879    messages.  Return 1 if the definition is particularly bad, or 0
8880    otherwise.  */
8881
8882 int
8883 check_static_variable_definition (decl, type)
8884      tree decl;
8885      tree type;
8886 {
8887   /* Motion 10 at San Diego: If a static const integral data member is
8888      initialized with an integral constant expression, the initializer
8889      may appear either in the declaration (within the class), or in
8890      the definition, but not both.  If it appears in the class, the
8891      member is a member constant.  The file-scope definition is always
8892      required.  */
8893   if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
8894     {
8895       cp_error ("in-class initialization of static data member of non-integral type `%T'",
8896                 type);
8897       /* If we just return the declaration, crashes will sometimes
8898          occur.  We therefore return void_type_node, as if this was a
8899          friend declaration, to cause callers to completely ignore
8900          this declaration.  */
8901       return 1;
8902     }
8903   else if (!CP_TYPE_CONST_P (type))
8904     cp_error ("ANSI C++ forbids in-class initialization of non-const static member `%D'",
8905               decl);
8906   else if (pedantic && !INTEGRAL_TYPE_P (type))
8907     cp_pedwarn ("ANSI C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
8908
8909   return 0;
8910 }
8911
8912 /* Given the SIZE (i.e., number of elements) in an array, compute an
8913    appropriate index type for the array.  If non-NULL, NAME is the
8914    name of the thing being declared.  */
8915
8916 tree
8917 compute_array_index_type (name, size)
8918      tree name;
8919      tree size;
8920 {
8921   tree itype;
8922
8923   /* The size might be the result of a cast. */
8924   STRIP_TYPE_NOPS (size);
8925
8926   /* It might be a const variable or enumeration constant.  */
8927   if (TREE_READONLY_DECL_P (size))
8928     size = decl_constant_value (size);
8929
8930   /* If this involves a template parameter, it will be a constant at
8931      instantiation time, but we don't know what the value is yet.
8932      Even if no template parameters are involved, we may an expression
8933      that is not a constant; we don't even simplify `1 + 2' when
8934      processing a template.  */
8935   if (processing_template_decl)
8936     {
8937       /* Resolve a qualified reference to an enumerator or static
8938          const data member of ours.  */
8939       if (TREE_CODE (size) == SCOPE_REF
8940           && TREE_OPERAND (size, 0) == current_class_type)
8941         {
8942           tree t = lookup_field (current_class_type,
8943                                  TREE_OPERAND (size, 1), 0, 0);
8944           if (t)
8945             size = t;
8946         }
8947
8948       return build_index_type (build_min (MINUS_EXPR, sizetype,
8949                                           size, integer_one_node));
8950     }
8951
8952   /* The array bound must be an integer type.  */
8953   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
8954       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
8955       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
8956     {
8957       if (name)
8958         cp_error ("size of array `%D' has non-integer type", name);
8959       else
8960         cp_error ("size of array has non-integer type");
8961       size = integer_one_node;
8962     }
8963
8964   /* Normally, the array-bound will be a constant.  */
8965   if (TREE_CONSTANT (size))
8966     {
8967       /* Check to see if the array bound overflowed.  Make that an
8968          error, no matter how generous we're being.  */
8969       int old_flag_pedantic_errors = flag_pedantic_errors;
8970       int old_pedantic = pedantic;
8971       pedantic = flag_pedantic_errors = 1;
8972       constant_expression_warning (size);
8973       pedantic = old_pedantic;
8974       flag_pedantic_errors = old_flag_pedantic_errors;
8975
8976       /* An array must have a positive number of elements.  */
8977       if (INT_CST_LT (size, integer_zero_node))
8978         {
8979           if (name)
8980             cp_error ("size of array `%D' is negative", name);
8981           else
8982             cp_error ("size of array is negative");
8983           size = integer_one_node;
8984         }
8985       /* Except that an extension we allow zero-sized arrays.  We
8986          always allow them in system headers because glibc uses
8987          them.  */
8988       else if (integer_zerop (size) && pedantic && !in_system_header)
8989         {
8990           if (name)
8991             cp_pedwarn ("ANSI C++ forbids zero-size array `%D'", name);
8992           else
8993             cp_pedwarn ("ANSI C++ forbids zero-size array");
8994         }
8995     }
8996
8997   /* Compute the index of the largest element in the array.  It is
8998      one less than the number of elements in the array.  */
8999   itype
9000     = fold (build_binary_op (MINUS_EXPR,
9001                              cp_convert (ssizetype, size),
9002                              cp_convert (ssizetype,
9003                                          integer_one_node)));
9004
9005   /* Check for variable-sized arrays.  We allow such things as an
9006      extension, even though they are not allowed in ANSI/ISO C++.  */
9007   if (!TREE_CONSTANT (itype))
9008     {
9009       if (pedantic)
9010         {
9011           if (name)
9012             cp_pedwarn ("ANSI C++ forbids variable-size array `%D'",
9013                         name);
9014           else
9015             cp_pedwarn ("ANSI C++ forbids variable-size array");
9016         }
9017
9018       /* Create a variable-sized array index type.  */
9019       itype = variable_size (itype);
9020     }
9021   /* Make sure that there was no overflow when creating to a signed
9022      index type.  (For example, on a 32-bit machine, an array with
9023      size 2^32 - 1 is too big.)  */
9024   else if (TREE_OVERFLOW (itype))
9025     {
9026       error ("overflow in array dimension");
9027       TREE_OVERFLOW (itype) = 0;
9028     }
9029
9030   /* Create and return the appropriate index type.  */
9031   return build_index_type (itype);
9032 }
9033
9034 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9035    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
9036    with this type.  */
9037
9038 static tree
9039 create_array_type_for_decl (name, type, size)
9040      tree name;
9041      tree type;
9042      tree size;
9043 {
9044   tree itype = NULL_TREE;
9045   const char* error_msg;
9046
9047   /* If things have already gone awry, bail now.  */
9048   if (type == error_mark_node || size == error_mark_node)
9049     return error_mark_node;
9050
9051   /* Assume that everything will go OK.  */
9052   error_msg = NULL;
9053
9054   /* There are some types which cannot be array elements.  */
9055   switch (TREE_CODE (type))
9056     {
9057     case VOID_TYPE:
9058       error_msg = "array of void";
9059       break;
9060
9061     case FUNCTION_TYPE:
9062       error_msg = "array of functions";
9063       break;
9064
9065     case REFERENCE_TYPE:
9066       error_msg = "array of references";
9067       break;
9068
9069     case OFFSET_TYPE:
9070       error_msg = "array of data members";
9071       break;
9072
9073     case METHOD_TYPE:
9074       error_msg = "array of function members";
9075       break;
9076
9077     default:
9078       break;
9079     }
9080
9081   /* If something went wrong, issue an error-message and return.  */
9082   if (error_msg)
9083     {
9084       if (name)
9085         cp_error ("declaration of `%D' as %s", name, error_msg);
9086       else
9087         cp_error ("creating %s", error_msg);
9088
9089       return error_mark_node;
9090     }
9091
9092   /* [dcl.array]
9093
9094      The constant expressions that specify the bounds of the arrays
9095      can be omitted only for the first member of the sequence.  */
9096   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9097     {
9098       cp_error ("declaration of `%D' as multidimensional array",
9099                 name);
9100       cp_error ("must have bounds for all dimensions except the first");
9101
9102       return error_mark_node;
9103     }
9104
9105   /* Figure out the index type for the array.  */
9106   if (size)
9107     itype = compute_array_index_type (name, size);
9108
9109   return build_cplus_array_type (type, itype);
9110 }
9111
9112 /* Given declspecs and a declarator,
9113    determine the name and type of the object declared
9114    and construct a ..._DECL node for it.
9115    (In one case we can return a ..._TYPE node instead.
9116     For invalid input we sometimes return 0.)
9117
9118    DECLSPECS is a chain of tree_list nodes whose value fields
9119     are the storage classes and type specifiers.
9120
9121    DECL_CONTEXT says which syntactic context this declaration is in:
9122      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9123      FUNCDEF for a function definition.  Like NORMAL but a few different
9124       error messages in each case.  Return value may be zero meaning
9125       this definition is too screwy to try to parse.
9126      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
9127       handle member functions (which have FIELD context).
9128       Return value may be zero meaning this definition is too screwy to
9129       try to parse.
9130      PARM for a parameter declaration (either within a function prototype
9131       or before a function body).  Make a PARM_DECL, or return void_type_node.
9132      CATCHPARM for a parameter declaration before a catch clause.
9133      TYPENAME if for a typename (in a cast or sizeof).
9134       Don't make a DECL node; just return the ..._TYPE node.
9135      FIELD for a struct or union field; make a FIELD_DECL.
9136      BITFIELD for a field with specified width.
9137    INITIALIZED is 1 if the decl has an initializer.
9138
9139    ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
9140    normal attributes in TREE_PURPOSE, or NULL_TREE.
9141
9142    In the TYPENAME case, DECLARATOR is really an abstract declarator.
9143    It may also be so in the PARM case, for a prototype where the
9144    argument type is specified but not the name.
9145
9146    This function is where the complicated C meanings of `static'
9147    and `extern' are interpreted.
9148
9149    For C++, if there is any monkey business to do, the function which
9150    calls this one must do it, i.e., prepending instance variables,
9151    renaming overloaded function names, etc.
9152
9153    Note that for this C++, it is an error to define a method within a class
9154    which does not belong to that class.
9155
9156    Except in the case where SCOPE_REFs are implicitly known (such as
9157    methods within a class being redundantly qualified),
9158    declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9159    (class_name::decl_name).  The caller must also deal with this.
9160
9161    If a constructor or destructor is seen, and the context is FIELD,
9162    then the type gains the attribute TREE_HAS_x.  If such a declaration
9163    is erroneous, NULL_TREE is returned.
9164
9165    QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
9166    function, these are the qualifiers to give to the `this' pointer. We
9167    apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9168
9169    May return void_type_node if the declarator turned out to be a friend.
9170    See grokfield for details.  */
9171
9172 enum return_types { return_normal, return_ctor, return_dtor, return_conversion };
9173
9174 tree
9175 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9176      tree declspecs;
9177      tree declarator;
9178      enum decl_context decl_context;
9179      int initialized;
9180      tree attrlist;
9181 {
9182   RID_BIT_TYPE specbits;
9183   int nclasses = 0;
9184   tree spec;
9185   tree type = NULL_TREE;
9186   int longlong = 0;
9187   int constp;
9188   int restrictp;
9189   int volatilep;
9190   int type_quals;
9191   int virtualp, explicitp, friendp, inlinep, staticp;
9192   int explicit_int = 0;
9193   int explicit_char = 0;
9194   int defaulted_int = 0;
9195   tree typedef_decl = NULL_TREE;
9196   const char *name;
9197   tree typedef_type = NULL_TREE;
9198   int funcdef_flag = 0;
9199   enum tree_code innermost_code = ERROR_MARK;
9200   int bitfield = 0;
9201 #if 0
9202   /* See the code below that used this.  */
9203   tree decl_machine_attr = NULL_TREE;
9204 #endif
9205   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9206      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9207   tree init = NULL_TREE;
9208
9209   /* Keep track of what sort of function is being processed
9210      so that we can warn about default return values, or explicit
9211      return values which do not match prescribed defaults.  */
9212   enum return_types return_type = return_normal;
9213
9214   tree dname = NULL_TREE;
9215   tree ctype = current_class_type;
9216   tree ctor_return_type = NULL_TREE;
9217   enum overload_flags flags = NO_SPECIAL;
9218   tree quals = NULL_TREE;
9219   tree raises = NULL_TREE;
9220   int template_count = 0;
9221   tree in_namespace = NULL_TREE;
9222   tree inner_attrs;
9223   int ignore_attrs;
9224
9225   RIDBIT_RESET_ALL (specbits);
9226   if (decl_context == FUNCDEF)
9227     funcdef_flag = 1, decl_context = NORMAL;
9228   else if (decl_context == MEMFUNCDEF)
9229     funcdef_flag = -1, decl_context = FIELD;
9230   else if (decl_context == BITFIELD)
9231     bitfield = 1, decl_context = FIELD;
9232
9233   /* Look inside a declarator for the name being declared
9234      and get it as a string, for an error message.  */
9235   {
9236     tree *next = &declarator;
9237     register tree decl;
9238     name = NULL;
9239
9240     while (next && *next)
9241       {
9242         decl = *next;
9243         switch (TREE_CODE (decl))
9244           {
9245           case TREE_LIST:
9246             /* For attributes.  */
9247             next = &TREE_VALUE (decl);
9248             break;
9249
9250           case COND_EXPR:
9251             ctype = NULL_TREE;
9252             next = &TREE_OPERAND (decl, 0);
9253             break;
9254
9255           case BIT_NOT_EXPR:    /* For C++ destructors!  */
9256             {
9257               tree name = TREE_OPERAND (decl, 0);
9258               tree rename = NULL_TREE;
9259
9260               my_friendly_assert (flags == NO_SPECIAL, 152);
9261               flags = DTOR_FLAG;
9262               return_type = return_dtor;
9263               if (TREE_CODE (name) == TYPE_DECL)
9264                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9265               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9266               if (ctype == NULL_TREE)
9267                 {
9268                   if (current_class_type == NULL_TREE)
9269                     {
9270                       error ("destructors must be member functions");
9271                       flags = NO_SPECIAL;
9272                     }
9273                   else
9274                     {
9275                       tree t = constructor_name (current_class_name);
9276                       if (t != name)
9277                         rename = t;
9278                     }
9279                 }
9280               else
9281                 {
9282                   tree t = constructor_name (ctype);
9283                   if (t != name)
9284                     rename = t;
9285                 }
9286
9287               if (rename)
9288                 {
9289                   cp_error ("destructor `%T' must match class name `%T'",
9290                             name, rename);
9291                   TREE_OPERAND (decl, 0) = rename;
9292                 }
9293               next = &name;
9294             }
9295             break;
9296
9297           case ADDR_EXPR:       /* C++ reference declaration */
9298             /* Fall through. */
9299           case ARRAY_REF:
9300           case INDIRECT_REF:
9301             ctype = NULL_TREE;
9302             innermost_code = TREE_CODE (decl);
9303             next = &TREE_OPERAND (decl, 0);
9304             break;
9305
9306           case CALL_EXPR:
9307             if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
9308               {
9309                 /* This is actually a variable declaration using
9310                    constructor syntax.  We need to call start_decl and
9311                    cp_finish_decl so we can get the variable
9312                    initialized...  */
9313
9314                 tree attributes, prefix_attributes;
9315
9316                 *next = TREE_OPERAND (decl, 0);
9317                 init = CALL_DECLARATOR_PARMS (decl);
9318
9319                 if (attrlist)
9320                   {
9321                     attributes = TREE_PURPOSE (attrlist);
9322                     prefix_attributes = TREE_VALUE (attrlist);
9323                   }
9324                 else
9325                   {
9326                     attributes = NULL_TREE;
9327                     prefix_attributes = NULL_TREE;
9328                   }
9329
9330                 decl = start_decl (declarator, declspecs, 1,
9331                                    attributes, prefix_attributes);
9332                 if (decl)
9333                   {
9334                     /* Look for __unused__ attribute */
9335                     if (TREE_USED (TREE_TYPE (decl)))
9336                       TREE_USED (decl) = 1;
9337                     finish_decl (decl, init, NULL_TREE);
9338                   }
9339                 else
9340                   cp_error ("invalid declarator");
9341                 return 0;
9342               }
9343             innermost_code = TREE_CODE (decl);
9344             if (decl_context == FIELD && ctype == NULL_TREE)
9345               ctype = current_class_type;
9346             if (ctype
9347                 && TREE_OPERAND (decl, 0)
9348                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9349                     && ((DECL_NAME (TREE_OPERAND (decl, 0))
9350                          == constructor_name_full (ctype))
9351                         || (DECL_NAME (TREE_OPERAND (decl, 0))
9352                             == constructor_name (ctype)))))
9353               TREE_OPERAND (decl, 0) = constructor_name (ctype);
9354             next = &TREE_OPERAND (decl, 0);
9355             decl = *next;
9356             if (ctype != NULL_TREE
9357                 && decl != NULL_TREE && flags != DTOR_FLAG
9358                 && decl == constructor_name (ctype))
9359               {
9360                 return_type = return_ctor;
9361                 ctor_return_type = ctype;
9362               }
9363             ctype = NULL_TREE;
9364             break;
9365
9366           case TEMPLATE_ID_EXPR:
9367               {
9368                 tree fns = TREE_OPERAND (decl, 0);
9369
9370                 if (TREE_CODE (fns) == LOOKUP_EXPR)
9371                   fns = TREE_OPERAND (fns, 0);
9372
9373                 dname = fns;
9374                 if (TREE_CODE (dname) == COMPONENT_REF)
9375                   dname = TREE_OPERAND (dname, 1);
9376                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9377                   {
9378                     my_friendly_assert (is_overloaded_fn (dname),
9379                                         19990331);
9380                     dname = DECL_NAME (get_first_fn (dname));
9381                   }
9382               }
9383           /* Fall through. */
9384
9385           case IDENTIFIER_NODE:
9386             if (TREE_CODE (decl) == IDENTIFIER_NODE)
9387               dname = decl;
9388
9389             next = 0;
9390
9391             if (is_rid (dname))
9392               {
9393                 cp_error ("declarator-id missing; using reserved word `%D'",
9394                           dname);
9395                 name = IDENTIFIER_POINTER (dname);
9396               }
9397             if (! IDENTIFIER_OPNAME_P (dname)
9398                 /* GNU/Linux headers use '__op'.  Arrgh.  */
9399                 || (IDENTIFIER_TYPENAME_P (dname) && ! TREE_TYPE (dname)))
9400               name = IDENTIFIER_POINTER (dname);
9401             else
9402               {
9403                 if (IDENTIFIER_TYPENAME_P (dname))
9404                   {
9405                     my_friendly_assert (flags == NO_SPECIAL, 154);
9406                     flags = TYPENAME_FLAG;
9407                     ctor_return_type = TREE_TYPE (dname);
9408                     return_type = return_conversion;
9409                   }
9410                 name = operator_name_string (dname);
9411               }
9412             break;
9413
9414             /* C++ extension */
9415           case SCOPE_REF:
9416             {
9417               /* Perform error checking, and decide on a ctype.  */
9418               tree cname = TREE_OPERAND (decl, 0);
9419               if (cname == NULL_TREE)
9420                 ctype = NULL_TREE;
9421               else if (TREE_CODE (cname) == NAMESPACE_DECL)
9422                 {
9423                   ctype = NULL_TREE;
9424                   in_namespace = TREE_OPERAND (decl, 0);
9425                   TREE_OPERAND (decl, 0) = NULL_TREE;
9426                 }
9427               else if (! is_aggr_type (cname, 1))
9428                 TREE_OPERAND (decl, 0) = NULL_TREE;
9429               /* Must test TREE_OPERAND (decl, 1), in case user gives
9430                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
9431               else if (TREE_OPERAND (decl, 1)
9432                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9433                 ctype = cname;
9434               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9435                        || TREE_CODE (cname) == TEMPLATE_TEMPLATE_PARM)
9436                 {
9437                   cp_error ("`%T::%D' is not a valid declarator", cname,
9438                             TREE_OPERAND (decl, 1));
9439                   cp_error ("  perhaps you want `typename %T::%D' to make it a type",
9440                             cname, TREE_OPERAND (decl, 1));
9441                   return void_type_node;
9442                 }
9443               else if (ctype == NULL_TREE)
9444                 ctype = cname;
9445               else if (TREE_COMPLEXITY (decl) == current_class_depth)
9446                 TREE_OPERAND (decl, 0) = ctype;
9447               else
9448                 {
9449                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9450                     {
9451                       cp_error ("type `%T' is not derived from type `%T'",
9452                                 cname, ctype);
9453                       TREE_OPERAND (decl, 0) = NULL_TREE;
9454                     }
9455                   else
9456                     ctype = cname;
9457                 }
9458
9459               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
9460                   && ((DECL_NAME (TREE_OPERAND (decl, 1))
9461                        == constructor_name_full (ctype))
9462                       || (DECL_NAME (TREE_OPERAND (decl, 1))
9463                           == constructor_name (ctype))))
9464                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
9465               next = &TREE_OPERAND (decl, 1);
9466               decl = *next;
9467               if (ctype)
9468                 {
9469                   if (TREE_CODE (decl) == IDENTIFIER_NODE
9470                       && constructor_name (ctype) == decl)
9471                     {
9472                       return_type = return_ctor;
9473                       ctor_return_type = ctype;
9474                     }
9475                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
9476                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
9477                            && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
9478                                || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
9479                     {
9480                       return_type = return_dtor;
9481                       ctor_return_type = ctype;
9482                       flags = DTOR_FLAG;
9483                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
9484                       next = &TREE_OPERAND (decl, 0);
9485                     }
9486                 }
9487             }
9488             break;
9489
9490           case ERROR_MARK:
9491             next = 0;
9492             break;
9493
9494           case TYPE_DECL:
9495             /* Parse error puts this typespec where
9496                a declarator should go.  */
9497             cp_error ("`%T' specified as declarator-id", DECL_NAME (decl));
9498             if (TREE_TYPE (decl) == current_class_type)
9499               cp_error ("  perhaps you want `%T' for a constructor",
9500                         current_class_name);
9501             dname = DECL_NAME (decl);
9502             name = IDENTIFIER_POINTER (dname);
9503
9504             /* Avoid giving two errors for this.  */
9505             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
9506
9507             declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
9508             *next = dname;
9509             next = 0;
9510             break;
9511
9512           default:
9513             cp_compiler_error ("`%D' as declarator", decl);
9514             return 0; /* We used to do a 155 abort here.  */
9515           }
9516       }
9517   }
9518
9519   /* A function definition's declarator must have the form of
9520      a function declarator.  */
9521
9522   if (funcdef_flag && innermost_code != CALL_EXPR)
9523     return 0;
9524
9525   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
9526       && innermost_code != CALL_EXPR
9527       && ! (ctype && declspecs == NULL_TREE))
9528     {
9529       cp_error ("declaration of `%D' as non-function", dname);
9530       return void_type_node;
9531     }
9532
9533   /* Anything declared one level down from the top level
9534      must be one of the parameters of a function
9535      (because the body is at least two levels down).  */
9536
9537   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9538      by not allowing C++ class definitions to specify their parameters
9539      with xdecls (must be spec.d in the parmlist).
9540
9541      Since we now wait to push a class scope until we are sure that
9542      we are in a legitimate method context, we must set oldcname
9543      explicitly (since current_class_name is not yet alive).
9544
9545      We also want to avoid calling this a PARM if it is in a namespace.  */
9546
9547   if (decl_context == NORMAL && !toplevel_bindings_p ())
9548     {
9549       struct binding_level *b = current_binding_level;
9550       current_binding_level = b->level_chain;
9551       if (current_binding_level != 0 && toplevel_bindings_p ())
9552         decl_context = PARM;
9553       current_binding_level = b;
9554     }
9555
9556   if (name == NULL)
9557     name = decl_context == PARM ? "parameter" : "type name";
9558
9559   /* Look through the decl specs and record which ones appear.
9560      Some typespecs are defined as built-in typenames.
9561      Others, the ones that are modifiers of other types,
9562      are represented by bits in SPECBITS: set the bits for
9563      the modifiers that appear.  Storage class keywords are also in SPECBITS.
9564
9565      If there is a typedef name or a type, store the type in TYPE.
9566      This includes builtin typedefs such as `int'.
9567
9568      Set EXPLICIT_INT if the type is `int' or `char' and did not
9569      come from a user typedef.
9570
9571      Set LONGLONG if `long' is mentioned twice.
9572
9573      For C++, constructors and destructors have their own fast treatment.  */
9574
9575   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
9576     {
9577       register int i;
9578       register tree id;
9579
9580       /* Certain parse errors slip through.  For example,
9581          `int class;' is not caught by the parser. Try
9582          weakly to recover here.  */
9583       if (TREE_CODE (spec) != TREE_LIST)
9584         return 0;
9585
9586       id = TREE_VALUE (spec);
9587
9588       if (TREE_CODE (id) == IDENTIFIER_NODE)
9589         {
9590           if (id == ridpointers[(int) RID_INT]
9591               || id == ridpointers[(int) RID_CHAR]
9592               || id == ridpointers[(int) RID_BOOL]
9593               || id == ridpointers[(int) RID_WCHAR])
9594             {
9595               if (type)
9596                 {
9597                   if (id == ridpointers[(int) RID_BOOL])
9598                     error ("`bool' is now a keyword");
9599                   else
9600                     cp_error ("extraneous `%T' ignored", id);
9601                 }
9602               else
9603                 {
9604                   if (id == ridpointers[(int) RID_INT])
9605                     explicit_int = 1;
9606                   else if (id == ridpointers[(int) RID_CHAR])
9607                     explicit_char = 1;
9608                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
9609                 }
9610               goto found;
9611             }
9612           /* C++ aggregate types.  */
9613           if (IDENTIFIER_HAS_TYPE_VALUE (id))
9614             {
9615               if (type)
9616                 cp_error ("multiple declarations `%T' and `%T'", type, id);
9617               else
9618                 type = IDENTIFIER_TYPE_VALUE (id);
9619               goto found;
9620             }
9621
9622           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
9623             {
9624               if (ridpointers[i] == id)
9625                 {
9626                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
9627                     {
9628                       if (pedantic && ! in_system_header && warn_long_long)
9629                         pedwarn ("ANSI C++ does not support `long long'");
9630                       if (longlong)
9631                         error ("`long long long' is too long for GCC");
9632                       else
9633                         longlong = 1;
9634                     }
9635                   else if (RIDBIT_SETP (i, specbits))
9636                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
9637                   RIDBIT_SET (i, specbits);
9638                   goto found;
9639                 }
9640             }
9641         }
9642       /* C++ aggregate types.  */
9643       else if (TREE_CODE (id) == TYPE_DECL || TREE_CODE (id) == TEMPLATE_DECL)
9644         {
9645           if (type)
9646             cp_error ("multiple declarations `%T' and `%T'", type,
9647                       TREE_TYPE (id));
9648           else
9649             {
9650               type = TREE_TYPE (id);
9651               TREE_VALUE (spec) = type;
9652             }
9653           goto found;
9654         }
9655       if (type)
9656         error ("two or more data types in declaration of `%s'", name);
9657       else if (TREE_CODE (id) == IDENTIFIER_NODE)
9658         {
9659           register tree t = lookup_name (id, 1);
9660           if (!t || TREE_CODE (t) != TYPE_DECL)
9661             error ("`%s' fails to be a typedef or built in type",
9662                    IDENTIFIER_POINTER (id));
9663           else
9664             {
9665               type = TREE_TYPE (t);
9666 #if 0
9667               /* See the code below that used this.  */
9668               decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
9669 #endif
9670               typedef_decl = t;
9671             }
9672         }
9673       else if (id != error_mark_node)
9674         /* Can't change CLASS nodes into RECORD nodes here!  */
9675         type = id;
9676
9677     found: ;
9678     }
9679
9680   typedef_type = type;
9681
9682   /* No type at all: default to `int', and set DEFAULTED_INT
9683      because it was not a user-defined typedef.  */
9684
9685   if (type == NULL_TREE
9686       && (RIDBIT_SETP (RID_SIGNED, specbits)
9687           || RIDBIT_SETP (RID_UNSIGNED, specbits)
9688           || RIDBIT_SETP (RID_LONG, specbits)
9689           || RIDBIT_SETP (RID_SHORT, specbits)))
9690     {
9691       /* These imply 'int'.  */
9692       type = integer_type_node;
9693       defaulted_int = 1;
9694     }
9695
9696   if (type == NULL_TREE)
9697     {
9698       explicit_int = -1;
9699       if (return_type == return_dtor)
9700         type = void_type_node;
9701       else if (return_type == return_ctor)
9702         type = build_pointer_type (ctor_return_type);
9703       else if (return_type == return_conversion)
9704         type = ctor_return_type;
9705       else
9706         {
9707           /* We handle `main' specially here, because 'main () { }' is so
9708              common.  With no options, it is allowed.  With -Wreturn-type,
9709              it is a warning.  It is only an error with -pedantic-errors.  */
9710           int is_main = (funcdef_flag
9711                          && MAIN_NAME_P (dname)
9712                          && ctype == NULL_TREE
9713                          && in_namespace == NULL_TREE
9714                          && current_namespace == global_namespace);
9715
9716           if (in_system_header || flag_ms_extensions)
9717             /* Allow it, sigh.  */;
9718           else if (pedantic || ! is_main)
9719             cp_pedwarn ("ANSI C++ forbids declaration of `%s' with no type",
9720                         name);
9721           else if (warn_return_type)
9722             cp_warning ("ANSI C++ forbids declaration of `%s' with no type",
9723                         name);
9724
9725           type = integer_type_node;
9726         }
9727     }
9728   else if (return_type == return_dtor)
9729     {
9730       error ("return type specification for destructor invalid");
9731       type = void_type_node;
9732     }
9733   else if (return_type == return_ctor)
9734     {
9735       error ("return type specification for constructor invalid");
9736       type = build_pointer_type (ctor_return_type);
9737     }
9738   else if (return_type == return_conversion)
9739     {
9740       if (!same_type_p (type, ctor_return_type))
9741         cp_error ("operator `%T' declared to return `%T'",
9742                   ctor_return_type, type);
9743       else
9744         cp_pedwarn ("return type specified for `operator %T'",
9745                     ctor_return_type);
9746
9747       type = ctor_return_type;
9748     }
9749
9750   ctype = NULL_TREE;
9751
9752   /* Now process the modifiers that were specified
9753      and check for invalid combinations.  */
9754
9755   /* Long double is a special combination.  */
9756
9757   if (RIDBIT_SETP (RID_LONG, specbits)
9758       && TYPE_MAIN_VARIANT (type) == double_type_node)
9759     {
9760       RIDBIT_RESET (RID_LONG, specbits);
9761       type = build_qualified_type (long_double_type_node,
9762                                    CP_TYPE_QUALS (type));
9763     }
9764
9765   /* Check all other uses of type modifiers.  */
9766
9767   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
9768       || RIDBIT_SETP (RID_SIGNED, specbits)
9769       || RIDBIT_SETP (RID_LONG, specbits)
9770       || RIDBIT_SETP (RID_SHORT, specbits))
9771     {
9772       int ok = 0;
9773
9774       if (TREE_CODE (type) == REAL_TYPE)
9775         error ("short, signed or unsigned invalid for `%s'", name);
9776       else if (TREE_CODE (type) != INTEGER_TYPE)
9777         error ("long, short, signed or unsigned invalid for `%s'", name);
9778       else if (RIDBIT_SETP (RID_LONG, specbits)
9779                && RIDBIT_SETP (RID_SHORT, specbits))
9780         error ("long and short specified together for `%s'", name);
9781       else if ((RIDBIT_SETP (RID_LONG, specbits)
9782                 || RIDBIT_SETP (RID_SHORT, specbits))
9783                && explicit_char)
9784         error ("long or short specified with char for `%s'", name);
9785       else if ((RIDBIT_SETP (RID_LONG, specbits)
9786                 || RIDBIT_SETP (RID_SHORT, specbits))
9787                && TREE_CODE (type) == REAL_TYPE)
9788         error ("long or short specified with floating type for `%s'", name);
9789       else if (RIDBIT_SETP (RID_SIGNED, specbits)
9790                && RIDBIT_SETP (RID_UNSIGNED, specbits))
9791         error ("signed and unsigned given together for `%s'", name);
9792       else
9793         {
9794           ok = 1;
9795           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
9796             {
9797               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
9798                        name);
9799               if (flag_pedantic_errors)
9800                 ok = 0;
9801             }
9802         }
9803
9804       /* Discard the type modifiers if they are invalid.  */
9805       if (! ok)
9806         {
9807           RIDBIT_RESET (RID_UNSIGNED, specbits);
9808           RIDBIT_RESET (RID_SIGNED, specbits);
9809           RIDBIT_RESET (RID_LONG, specbits);
9810           RIDBIT_RESET (RID_SHORT, specbits);
9811           longlong = 0;
9812         }
9813     }
9814
9815   if (RIDBIT_SETP (RID_COMPLEX, specbits)
9816       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
9817     {
9818       error ("complex invalid for `%s'", name);
9819       RIDBIT_RESET (RID_COMPLEX, specbits);
9820     }
9821
9822   /* Decide whether an integer type is signed or not.
9823      Optionally treat bitfields as signed by default.  */
9824   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
9825       /* [class.bit]
9826
9827          It is implementation-defined whether a plain (neither
9828          explicitly signed or unsigned) char, short, int, or long
9829          bit-field is signed or unsigned.
9830
9831          Naturally, we extend this to long long as well.  Note that
9832          this does not include wchar_t.  */
9833       || (bitfield && !flag_signed_bitfields
9834           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
9835           /* A typedef for plain `int' without `signed' can be
9836              controlled just like plain `int', but a typedef for
9837              `signed int' cannot be so controlled.  */
9838           && !(typedef_decl
9839                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
9840           && (TREE_CODE (type) == INTEGER_TYPE
9841               || TREE_CODE (type) == CHAR_TYPE)
9842           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
9843     {
9844       if (longlong)
9845         type = long_long_unsigned_type_node;
9846       else if (RIDBIT_SETP (RID_LONG, specbits))
9847         type = long_unsigned_type_node;
9848       else if (RIDBIT_SETP (RID_SHORT, specbits))
9849         type = short_unsigned_type_node;
9850       else if (type == char_type_node)
9851         type = unsigned_char_type_node;
9852       else if (typedef_decl)
9853         type = unsigned_type (type);
9854       else
9855         type = unsigned_type_node;
9856     }
9857   else if (RIDBIT_SETP (RID_SIGNED, specbits)
9858            && type == char_type_node)
9859     type = signed_char_type_node;
9860   else if (longlong)
9861     type = long_long_integer_type_node;
9862   else if (RIDBIT_SETP (RID_LONG, specbits))
9863     type = long_integer_type_node;
9864   else if (RIDBIT_SETP (RID_SHORT, specbits))
9865     type = short_integer_type_node;
9866
9867   if (RIDBIT_SETP (RID_COMPLEX, specbits))
9868     {
9869       /* If we just have "complex", it is equivalent to
9870          "complex double", but if any modifiers at all are specified it is
9871          the complex form of TYPE.  E.g, "complex short" is
9872          "complex short int".  */
9873
9874       if (defaulted_int && ! longlong
9875           && ! (RIDBIT_SETP (RID_LONG, specbits)
9876                 || RIDBIT_SETP (RID_SHORT, specbits)
9877                 || RIDBIT_SETP (RID_SIGNED, specbits)
9878                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
9879         type = complex_double_type_node;
9880       else if (type == integer_type_node)
9881         type = complex_integer_type_node;
9882       else if (type == float_type_node)
9883         type = complex_float_type_node;
9884       else if (type == double_type_node)
9885         type = complex_double_type_node;
9886       else if (type == long_double_type_node)
9887         type = complex_long_double_type_node;
9888       else
9889         type = build_complex_type (type);
9890     }
9891
9892   if (return_type == return_conversion
9893       && (RIDBIT_SETP (RID_CONST, specbits)
9894           || RIDBIT_SETP (RID_VOLATILE, specbits)
9895           || RIDBIT_SETP (RID_RESTRICT, specbits)))
9896     cp_error ("qualifiers are not allowed on declaration of `operator %T'",
9897               ctor_return_type);
9898
9899   /* Set CONSTP if this declaration is `const', whether by
9900      explicit specification or via a typedef.
9901      Likewise for VOLATILEP.  */
9902
9903   constp = !! RIDBIT_SETP (RID_CONST, specbits) + CP_TYPE_CONST_P (type);
9904   restrictp =
9905     !! RIDBIT_SETP (RID_RESTRICT, specbits) + CP_TYPE_RESTRICT_P (type);
9906   volatilep =
9907     !! RIDBIT_SETP (RID_VOLATILE, specbits) + CP_TYPE_VOLATILE_P (type);
9908   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
9909                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
9910                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
9911   type = cp_build_qualified_type (type, type_quals);
9912   staticp = 0;
9913   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
9914   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
9915   RIDBIT_RESET (RID_VIRTUAL, specbits);
9916   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
9917   RIDBIT_RESET (RID_EXPLICIT, specbits);
9918
9919   if (RIDBIT_SETP (RID_STATIC, specbits))
9920     staticp = 1 + (decl_context == FIELD);
9921
9922   if (virtualp && staticp == 2)
9923     {
9924       cp_error ("member `%D' cannot be declared both virtual and static",
9925                 dname);
9926       staticp = 0;
9927     }
9928   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
9929   RIDBIT_RESET (RID_FRIEND, specbits);
9930
9931   /* Warn if two storage classes are given. Default to `auto'.  */
9932
9933   if (RIDBIT_ANY_SET (specbits))
9934     {
9935       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
9936       if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
9937       if (decl_context == PARM && nclasses > 0)
9938         error ("storage class specifiers invalid in parameter declarations");
9939       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
9940         {
9941           if (decl_context == PARM)
9942             error ("typedef declaration invalid in parameter declaration");
9943           nclasses++;
9944         }
9945       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
9946       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
9947     }
9948
9949   /* Give error if `virtual' is used outside of class declaration.  */
9950   if (virtualp
9951       && (current_class_name == NULL_TREE || decl_context != FIELD))
9952     {
9953       error ("virtual outside class declaration");
9954       virtualp = 0;
9955     }
9956
9957   /* Static anonymous unions are dealt with here.  */
9958   if (staticp && decl_context == TYPENAME
9959       && TREE_CODE (declspecs) == TREE_LIST
9960       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
9961     decl_context = FIELD;
9962
9963   /* Warn about storage classes that are invalid for certain
9964      kinds of declarations (parameters, typenames, etc.).  */
9965
9966   if (nclasses > 1)
9967     error ("multiple storage classes in declaration of `%s'", name);
9968   else if (decl_context != NORMAL && nclasses > 0)
9969     {
9970       if ((decl_context == PARM || decl_context == CATCHPARM)
9971           && (RIDBIT_SETP (RID_REGISTER, specbits)
9972               || RIDBIT_SETP (RID_AUTO, specbits)))
9973         ;
9974       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
9975         ;
9976       else if (decl_context == FIELD
9977                /* C++ allows static class elements  */
9978                && RIDBIT_SETP (RID_STATIC, specbits))
9979         /* C++ also allows inlines and signed and unsigned elements,
9980            but in those cases we don't come in here.  */
9981         ;
9982       else
9983         {
9984           if (decl_context == FIELD)
9985             {
9986               tree tmp = NULL_TREE;
9987               register int op = 0;
9988
9989               if (declarator)
9990                 {
9991                   /* Avoid trying to get an operand off an identifier node.  */
9992                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
9993                     tmp = declarator;
9994                   else
9995                     tmp = TREE_OPERAND (declarator, 0);
9996                   op = IDENTIFIER_OPNAME_P (tmp);
9997                 }
9998               error ("storage class specified for %s `%s'",
9999                      op ? "member operator" : "field",
10000                      op ? operator_name_string (tmp) : name);
10001             }
10002           else
10003             {
10004               if (decl_context == PARM || decl_context == CATCHPARM)
10005                 error ("storage class specified for parameter `%s'", name);
10006               else
10007                 error ("storage class specified for typename");
10008             }
10009           RIDBIT_RESET (RID_REGISTER, specbits);
10010           RIDBIT_RESET (RID_AUTO, specbits);
10011           RIDBIT_RESET (RID_EXTERN, specbits);
10012         }
10013     }
10014   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10015     {
10016       if (toplevel_bindings_p ())
10017         {
10018           /* It's common practice (and completely valid) to have a const
10019              be initialized and declared extern.  */
10020           if (!(type_quals & TYPE_QUAL_CONST))
10021             warning ("`%s' initialized and declared `extern'", name);
10022         }
10023       else
10024         error ("`%s' has both `extern' and initializer", name);
10025     }
10026   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10027            && ! toplevel_bindings_p ())
10028     error ("nested function `%s' declared `extern'", name);
10029   else if (toplevel_bindings_p ())
10030     {
10031       if (RIDBIT_SETP (RID_AUTO, specbits))
10032         error ("top-level declaration of `%s' specifies `auto'", name);
10033     }
10034
10035   if (nclasses > 0 && friendp)
10036     error ("storage class specifiers invalid in friend function declarations");
10037
10038   /* Now figure out the structure of the declarator proper.
10039      Descend through it, creating more complex types, until we reach
10040      the declared identifier (or NULL_TREE, in an absolute declarator).  */
10041
10042   inner_attrs = NULL_TREE;
10043   ignore_attrs = 0;
10044
10045   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10046          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10047     {
10048       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10049          an INDIRECT_REF (for *...),
10050          a CALL_EXPR (for ...(...)),
10051          an identifier (for the name being declared)
10052          or a null pointer (for the place in an absolute declarator
10053          where the name was omitted).
10054          For the last two cases, we have just exited the loop.
10055
10056          For C++ it could also be
10057          a SCOPE_REF (for class :: ...).  In this case, we have converted
10058          sensible names to types, and those are the values we use to
10059          qualify the member name.
10060          an ADDR_EXPR (for &...),
10061          a BIT_NOT_EXPR (for destructors)
10062
10063          At this point, TYPE is the type of elements of an array,
10064          or for a function to return, or for a pointer to point to.
10065          After this sequence of ifs, TYPE is the type of the
10066          array or function or pointer, and DECLARATOR has had its
10067          outermost layer removed.  */
10068
10069       if (type == error_mark_node)
10070         {
10071           if (TREE_CODE (declarator) == SCOPE_REF)
10072             declarator = TREE_OPERAND (declarator, 1);
10073           else
10074             declarator = TREE_OPERAND (declarator, 0);
10075           continue;
10076         }
10077       if (quals != NULL_TREE
10078           && (declarator == NULL_TREE
10079               || TREE_CODE (declarator) != SCOPE_REF))
10080         {
10081           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10082             ctype = TYPE_METHOD_BASETYPE (type);
10083           if (ctype != NULL_TREE)
10084             {
10085               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10086               grok_method_quals (ctype, dummy, quals);
10087               type = TREE_TYPE (dummy);
10088               ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
10089               quals = NULL_TREE;
10090             }
10091         }
10092
10093       /* See the comment for the TREE_LIST case, below.  */
10094       if (ignore_attrs)
10095         ignore_attrs = 0;
10096       else if (inner_attrs)
10097         {
10098           decl_attributes (type, inner_attrs, NULL_TREE);
10099           inner_attrs = NULL_TREE;
10100         }
10101
10102       switch (TREE_CODE (declarator))
10103         {
10104         case TREE_LIST:
10105           {
10106             /* We encode a declarator with embedded attributes using
10107                a TREE_LIST.  The attributes apply to the declarator
10108                directly inside them, so we have to skip an iteration
10109                before applying them to the type.  If the declarator just
10110                inside is the declarator-id, we apply the attrs to the
10111                decl itself.  */
10112             inner_attrs = TREE_PURPOSE (declarator);
10113             ignore_attrs = 1;
10114             declarator = TREE_VALUE (declarator);
10115           }
10116           break;
10117
10118         case ARRAY_REF:
10119           {
10120             register tree size;
10121
10122             size = TREE_OPERAND (declarator, 1);
10123
10124             /* VC++ spells a zero-sized array with [].  */
10125             if (size == NULL_TREE && decl_context == FIELD && ! staticp
10126                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10127               size = integer_zero_node;
10128
10129             declarator = TREE_OPERAND (declarator, 0);
10130
10131             type = create_array_type_for_decl (dname, type, size);
10132             ctype = NULL_TREE;
10133           }
10134           break;
10135
10136         case CALL_EXPR:
10137           {
10138             tree arg_types;
10139             int funcdecl_p;
10140             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10141             tree inner_decl = TREE_OPERAND (declarator, 0);
10142
10143             /* Declaring a function type.
10144                Make sure we have a valid type for the function to return.  */
10145
10146             /* We now know that the TYPE_QUALS don't apply to the
10147                decl, but to its return type.  */
10148             type_quals = TYPE_UNQUALIFIED;
10149
10150             /* Warn about some types functions can't return.  */
10151
10152             if (TREE_CODE (type) == FUNCTION_TYPE)
10153               {
10154                 error ("`%s' declared as function returning a function", name);
10155                 type = integer_type_node;
10156               }
10157             if (TREE_CODE (type) == ARRAY_TYPE)
10158               {
10159                 error ("`%s' declared as function returning an array", name);
10160                 type = integer_type_node;
10161               }
10162
10163             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10164               inner_decl = TREE_OPERAND (inner_decl, 1);
10165
10166             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10167               inner_decl = dname;
10168
10169             /* Pick up type qualifiers which should be applied to `this'.  */
10170             quals = CALL_DECLARATOR_QUALS (declarator);
10171
10172             /* Pick up the exception specifications.  */
10173             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10174
10175             /* Say it's a definition only for the CALL_EXPR
10176                closest to the identifier.  */
10177             funcdecl_p
10178               = inner_decl
10179               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10180                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10181                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10182
10183             if (ctype == NULL_TREE
10184                 && decl_context == FIELD
10185                 && funcdecl_p
10186                 && (friendp == 0 || dname == current_class_name))
10187               ctype = current_class_type;
10188
10189             if (ctype && return_type == return_conversion)
10190               TYPE_HAS_CONVERSION (ctype) = 1;
10191             if (ctype && constructor_name (ctype) == dname)
10192               {
10193                 /* We are within a class's scope. If our declarator name
10194                    is the same as the class name, and we are defining
10195                    a function, then it is a constructor/destructor, and
10196                    therefore returns a void type.  */
10197
10198                 if (flags == DTOR_FLAG)
10199                   {
10200                     /* ANSI C++ June 5 1992 WP 12.4.1.  A destructor may
10201                        not be declared const or volatile.  A destructor
10202                        may not be static.  */
10203                     if (staticp == 2)
10204                       error ("destructor cannot be static member function");
10205                     if (quals)
10206                       {
10207                         cp_error ("destructors may not be `%s'",
10208                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10209                         quals = NULL_TREE;
10210                       }
10211                     if (decl_context == FIELD)
10212                       {
10213                         if (! member_function_or_else (ctype,
10214                                                        current_class_type,
10215                                                        flags))
10216                           return void_type_node;
10217                       }
10218                   }
10219                 else            /* It's a constructor.  */
10220                   {
10221                     if (explicitp == 1)
10222                       explicitp = 2;
10223                     /* ANSI C++ June 5 1992 WP 12.1.2.  A constructor may
10224                        not be declared const or volatile.  A constructor may
10225                        not be virtual.  A constructor may not be static.  */
10226                     if (staticp == 2)
10227                       error ("constructor cannot be static member function");
10228                     if (virtualp)
10229                       {
10230                         pedwarn ("constructors cannot be declared virtual");
10231                         virtualp = 0;
10232                       }
10233                     if (quals)
10234                       {
10235                         cp_error ("constructors may not be `%s'",
10236                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10237                         quals = NULL_TREE;
10238                       }
10239                     {
10240                       RID_BIT_TYPE tmp_bits;
10241                       bcopy ((void*)&specbits, (void*)&tmp_bits, sizeof (RID_BIT_TYPE));
10242                       RIDBIT_RESET (RID_INLINE, tmp_bits);
10243                       RIDBIT_RESET (RID_STATIC, tmp_bits);
10244                       if (RIDBIT_ANY_SET (tmp_bits))
10245                         error ("return value type specifier for constructor ignored");
10246                     }
10247                     type = build_pointer_type (ctype);
10248                     if (decl_context == FIELD)
10249                       {
10250                         if (! member_function_or_else (ctype,
10251                                                        current_class_type,
10252                                                        flags))
10253                           return void_type_node;
10254                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10255                         if (return_type != return_ctor)
10256                           return NULL_TREE;
10257                       }
10258                   }
10259                 if (decl_context == FIELD)
10260                   staticp = 0;
10261               }
10262             else if (friendp)
10263               {
10264                 if (initialized)
10265                   error ("can't initialize friend function `%s'", name);
10266                 if (virtualp)
10267                   {
10268                     /* Cannot be both friend and virtual.  */
10269                     error ("virtual functions cannot be friends");
10270                     RIDBIT_RESET (RID_FRIEND, specbits);
10271                     friendp = 0;
10272                   }
10273                 if (decl_context == NORMAL)
10274                   error ("friend declaration not in class definition");
10275                 if (current_function_decl && funcdef_flag)
10276                   cp_error ("can't define friend function `%s' in a local class definition",
10277                             name);
10278               }
10279
10280             /* Construct the function type and go to the next
10281                inner layer of declarator.  */
10282
10283             declarator = TREE_OPERAND (declarator, 0);
10284
10285             /* FIXME: This is where default args should be fully
10286                processed.  */
10287
10288             arg_types = grokparms (inner_parms, funcdecl_p ? funcdef_flag : 0);
10289
10290             if (declarator && flags == DTOR_FLAG)
10291               {
10292                 /* A destructor declared in the body of a class will
10293                    be represented as a BIT_NOT_EXPR.  But, we just
10294                    want the underlying IDENTIFIER.  */
10295                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10296                   declarator = TREE_OPERAND (declarator, 0);
10297
10298                 if (strict_prototype == 0 && arg_types == NULL_TREE)
10299                   arg_types = void_list_node;
10300                 else if (arg_types == NULL_TREE
10301                          || arg_types != void_list_node)
10302                   {
10303                     cp_error ("destructors may not have parameters");
10304                     arg_types = void_list_node;
10305                     last_function_parms = NULL_TREE;
10306                   }
10307               }
10308
10309             /* ANSI says that `const int foo ();'
10310                does not make the function foo const.  */
10311             type = build_function_type (type, arg_types);
10312
10313             {
10314               tree t;
10315               for (t = arg_types; t; t = TREE_CHAIN (t))
10316                 if (TREE_PURPOSE (t)
10317                     && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10318                   {
10319                     add_defarg_fn (type);
10320                     break;
10321                   }
10322             }
10323           }
10324           break;
10325
10326         case ADDR_EXPR:
10327         case INDIRECT_REF:
10328           /* Filter out pointers-to-references and references-to-references.
10329              We can get these if a TYPE_DECL is used.  */
10330
10331           if (TREE_CODE (type) == REFERENCE_TYPE)
10332             {
10333               error ("cannot declare %s to references",
10334                      TREE_CODE (declarator) == ADDR_EXPR
10335                      ? "references" : "pointers");
10336               declarator = TREE_OPERAND (declarator, 0);
10337               continue;
10338             }
10339
10340           if (TREE_CODE (type) == OFFSET_TYPE
10341               && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10342                   || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10343             {
10344               cp_error ("cannot declare pointer to `%#T' member",
10345                         TREE_TYPE (type));
10346               type = TREE_TYPE (type);
10347             }
10348
10349           /* Merge any constancy or volatility into the target type
10350              for the pointer.  */
10351
10352           /* We now know that the TYPE_QUALS don't apply to the decl,
10353              but to the target of the pointer.  */
10354           type_quals = TYPE_UNQUALIFIED;
10355
10356           if (TREE_CODE (declarator) == ADDR_EXPR)
10357             {
10358               if (TREE_CODE (type) == VOID_TYPE)
10359                 error ("invalid type: `void &'");
10360               else
10361                 type = build_reference_type (type);
10362             }
10363           else if (TREE_CODE (type) == METHOD_TYPE)
10364             type = build_ptrmemfunc_type (build_pointer_type (type));
10365           else
10366             type = build_pointer_type (type);
10367
10368           /* Process a list of type modifier keywords (such as
10369              const or volatile) that were given inside the `*' or `&'.  */
10370
10371           if (TREE_TYPE (declarator))
10372             {
10373               register tree typemodlist;
10374               int erred = 0;
10375
10376               constp = 0;
10377               volatilep = 0;
10378               restrictp = 0;
10379               for (typemodlist = TREE_TYPE (declarator); typemodlist;
10380                    typemodlist = TREE_CHAIN (typemodlist))
10381                 {
10382                   tree qualifier = TREE_VALUE (typemodlist);
10383
10384                   if (qualifier == ridpointers[(int) RID_CONST])
10385                     constp++;
10386                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
10387                     volatilep++;
10388                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
10389                     restrictp++;
10390                   else if (!erred)
10391                     {
10392                       erred = 1;
10393                       error ("invalid type modifier within pointer declarator");
10394                     }
10395                 }
10396               if (constp > 1)
10397                 pedwarn ("duplicate `const'");
10398               if (volatilep > 1)
10399                 pedwarn ("duplicate `volatile'");
10400               if (restrictp > 1)
10401                 pedwarn ("duplicate `restrict'");
10402
10403               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10404                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10405                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10406               if (TREE_CODE (declarator) == ADDR_EXPR
10407                   && (constp || volatilep))
10408                 {
10409                   if (constp)
10410                     pedwarn ("discarding `const' applied to a reference");
10411                   if (volatilep)
10412                     pedwarn ("discarding `volatile' applied to a reference");
10413                   type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
10414                 }
10415               type = cp_build_qualified_type (type, type_quals);
10416             }
10417           declarator = TREE_OPERAND (declarator, 0);
10418           ctype = NULL_TREE;
10419           break;
10420
10421         case SCOPE_REF:
10422           {
10423             /* We have converted type names to NULL_TREE if the
10424                name was bogus, or to a _TYPE node, if not.
10425
10426                The variable CTYPE holds the type we will ultimately
10427                resolve to.  The code here just needs to build
10428                up appropriate member types.  */
10429             tree sname = TREE_OPERAND (declarator, 1);
10430             tree t;
10431
10432             /* Destructors can have their visibilities changed as well.  */
10433             if (TREE_CODE (sname) == BIT_NOT_EXPR)
10434               sname = TREE_OPERAND (sname, 0);
10435
10436             if (TREE_COMPLEXITY (declarator) == 0)
10437               /* This needs to be here, in case we are called
10438                  multiple times.  */ ;
10439             else if (TREE_COMPLEXITY (declarator) == -1)
10440               /* Namespace member. */
10441               pop_decl_namespace ();
10442             else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
10443               /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10444             else if (! IS_AGGR_TYPE_CODE
10445                      (TREE_CODE (TREE_OPERAND (declarator, 0))))
10446               ;
10447             else if (TREE_COMPLEXITY (declarator) == current_class_depth)
10448               {
10449                 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10450                    that refer to ctype.  They couldn't be resolved earlier
10451                    because we hadn't pushed into the class yet.
10452                    Example: resolve 'B<T>::type' in
10453                    'B<typename B<T>::type> B<T>::f () { }'.  */
10454                 if (current_template_parms
10455                     && uses_template_parms (type)
10456                     && uses_template_parms (current_class_type))
10457                   {
10458                     tree args = current_template_args ();
10459                     type = tsubst (type, args, /*complain=*/1, NULL_TREE);
10460                   }
10461
10462                 /* This pop_nested_class corresponds to the
10463                    push_nested_class used to push into class scope for
10464                    parsing the argument list of a function decl, in
10465                    qualified_id.  */
10466                 pop_nested_class ();
10467                 TREE_COMPLEXITY (declarator) = current_class_depth;
10468               }
10469             else
10470               my_friendly_abort (16);
10471
10472             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
10473               {
10474                 /* We had a reference to a global decl, or
10475                    perhaps we were given a non-aggregate typedef,
10476                    in which case we cleared this out, and should just
10477                    keep going as though it wasn't there.  */
10478                 declarator = sname;
10479                 continue;
10480               }
10481             ctype = TREE_OPERAND (declarator, 0);
10482
10483             t = ctype;
10484             while (t != NULL_TREE && CLASS_TYPE_P (t))
10485               {
10486                 if (CLASSTYPE_TEMPLATE_INFO (t) &&
10487                     !CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
10488                   template_count += 1;
10489                 t = TYPE_MAIN_DECL (t);
10490                 if (DECL_LANG_SPECIFIC (t))
10491                   t = DECL_CLASS_CONTEXT (t);
10492                 else
10493                   t = NULL_TREE;
10494               }
10495
10496             if (sname == NULL_TREE)
10497               goto done_scoping;
10498
10499             if (TREE_CODE (sname) == IDENTIFIER_NODE)
10500               {
10501                 /* This is the `standard' use of the scoping operator:
10502                    basetype :: member .  */
10503
10504                 if (ctype == current_class_type)
10505                   {
10506                     /* class A {
10507                          void A::f ();
10508                        };
10509
10510                        Is this ill-formed?  */
10511
10512                     if (pedantic)
10513                       cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10514                                   ctype, name);
10515                   }
10516                 else if (TREE_CODE (type) == FUNCTION_TYPE)
10517                   {
10518                     if (current_class_type == NULL_TREE
10519                         || friendp)
10520                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10521                                                       TYPE_ARG_TYPES (type));
10522                     else
10523                       {
10524                         cp_error ("cannot declare member function `%T::%s' within `%T'",
10525                                   ctype, name, current_class_type);
10526                         return void_type_node;
10527                       }
10528                   }
10529                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
10530                          || TYPE_SIZE (complete_type (ctype)) != NULL_TREE)
10531                   {
10532                     /* Have to move this code elsewhere in this function.
10533                        this code is used for i.e., typedef int A::M; M *pm;
10534
10535                        It is?  How? jason 10/2/94 */
10536
10537                     if (current_class_type)
10538                       {
10539                         cp_error ("cannot declare member `%T::%s' within `%T'",
10540                                   ctype, name, current_class_type);
10541                         return void_type_node;
10542                       }
10543                     type = build_offset_type (ctype, type);
10544                   }
10545                 else if (uses_template_parms (ctype))
10546                   {
10547                     if (TREE_CODE (type) == FUNCTION_TYPE)
10548                       type
10549                         = build_cplus_method_type (ctype, TREE_TYPE (type),
10550                                                    TYPE_ARG_TYPES (type));
10551                   }
10552                 else
10553                   {
10554                     cp_error ("structure `%T' not yet defined", ctype);
10555                     return error_mark_node;
10556                   }
10557
10558                 declarator = sname;
10559               }
10560             else if (TREE_CODE (sname) == SCOPE_REF)
10561               my_friendly_abort (17);
10562             else
10563               {
10564               done_scoping:
10565                 declarator = TREE_OPERAND (declarator, 1);
10566                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
10567                   /* In this case, we will deal with it later.  */
10568                   ;
10569                 else
10570                   {
10571                     if (TREE_CODE (type) == FUNCTION_TYPE)
10572                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10573                                                       TYPE_ARG_TYPES (type));
10574                     else
10575                       type = build_offset_type (ctype, type);
10576                   }
10577               }
10578           }
10579           break;
10580
10581         case BIT_NOT_EXPR:
10582           declarator = TREE_OPERAND (declarator, 0);
10583           break;
10584
10585         case RECORD_TYPE:
10586         case UNION_TYPE:
10587         case ENUMERAL_TYPE:
10588           declarator = NULL_TREE;
10589           break;
10590
10591         case ERROR_MARK:
10592           declarator = NULL_TREE;
10593           break;
10594
10595         default:
10596           my_friendly_abort (158);
10597         }
10598     }
10599
10600   /* See the comment for the TREE_LIST case, above.  */
10601   if (inner_attrs)
10602     {
10603       if (! ignore_attrs)
10604         decl_attributes (type, inner_attrs, NULL_TREE);
10605       else if (attrlist)
10606         TREE_VALUE (attrlist) = chainon (inner_attrs, TREE_VALUE (attrlist));
10607       else
10608         attrlist = build_decl_list (NULL_TREE, inner_attrs);
10609     }
10610
10611   /* Now TYPE has the actual type.  */
10612
10613   if (explicitp == 1 || (explicitp && friendp))
10614     {
10615       /* [dcl.fct.spec] The explicit specifier shall only be used in
10616          declarations of constructors within a class definition.  */
10617       error ("only declarations of constructors can be `explicit'");
10618       explicitp = 0;
10619     }
10620
10621   if (RIDBIT_SETP (RID_MUTABLE, specbits))
10622     {
10623       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
10624         {
10625           error ("non-member `%s' cannot be declared `mutable'", name);
10626           RIDBIT_RESET (RID_MUTABLE, specbits);
10627         }
10628       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
10629         {
10630           error ("non-object member `%s' cannot be declared `mutable'", name);
10631           RIDBIT_RESET (RID_MUTABLE, specbits);
10632         }
10633       else if (TREE_CODE (type) == FUNCTION_TYPE
10634                || TREE_CODE (type) == METHOD_TYPE)
10635         {
10636           error ("function `%s' cannot be declared `mutable'", name);
10637           RIDBIT_RESET (RID_MUTABLE, specbits);
10638         }
10639       else if (staticp)
10640         {
10641           error ("static `%s' cannot be declared `mutable'", name);
10642           RIDBIT_RESET (RID_MUTABLE, specbits);
10643         }
10644       else if (type_quals & TYPE_QUAL_CONST)
10645         {
10646           error ("const `%s' cannot be declared `mutable'", name);
10647           RIDBIT_RESET (RID_MUTABLE, specbits);
10648         }
10649     }
10650
10651   if (declarator == NULL_TREE
10652       || TREE_CODE (declarator) == IDENTIFIER_NODE
10653       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
10654           && (TREE_CODE (type) == FUNCTION_TYPE
10655               || TREE_CODE (type) == METHOD_TYPE)))
10656     /* OK */;
10657   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
10658     {
10659       cp_error ("template-id `%D' used as a declarator", declarator);
10660       declarator = dname;
10661     }
10662   else
10663     /* Unexpected declarator format.  */
10664     my_friendly_abort (990210);
10665
10666   /* If this is declaring a typedef name, return a TYPE_DECL.  */
10667
10668   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
10669     {
10670       tree decl;
10671
10672       /* Note that the grammar rejects storage classes
10673          in typenames, fields or parameters.  */
10674       if (current_lang_name == lang_name_java)
10675         TYPE_FOR_JAVA (type) = 1;
10676
10677       if (decl_context == FIELD)
10678         {
10679           if (declarator == constructor_name (current_class_type))
10680             cp_pedwarn ("ANSI C++ forbids nested type `%D' with same name as enclosing class",
10681                         declarator);
10682           decl = build_lang_decl (TYPE_DECL, declarator, type);
10683         }
10684       else
10685         {
10686           /* Make sure this typedef lives as long as its type,
10687              since it might be used as a template parameter. */
10688           if (processing_template_decl)
10689             decl = build_lang_decl (TYPE_DECL, declarator, type);
10690           else
10691             decl = build_decl (TYPE_DECL, declarator, type);
10692         }
10693
10694       /* If the user declares "typedef struct {...} foo" then the
10695          struct will have an anonymous name.  Fill that name in now.
10696          Nothing can refer to it, so nothing needs know about the name
10697          change.  */
10698       if (type != error_mark_node
10699           && TYPE_NAME (type)
10700           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
10701           && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type))
10702           && CP_TYPE_QUALS (type) == TYPE_UNQUALIFIED)
10703         {
10704           tree oldname = TYPE_NAME (type);
10705           tree t;
10706
10707           /* Replace the anonymous name with the real name everywhere.  */
10708           lookup_tag_reverse (type, declarator);
10709           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
10710             if (TYPE_NAME (t) == oldname)
10711               TYPE_NAME (t) = decl;
10712
10713           if (TYPE_LANG_SPECIFIC (type))
10714             TYPE_WAS_ANONYMOUS (type) = 1;
10715
10716           /* If this is a typedef within a template class, the nested
10717              type is a (non-primary) template.  The name for the
10718              template needs updating as well.  */
10719           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
10720             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
10721               = TYPE_IDENTIFIER (type);
10722
10723           /* XXX Temporarily set the scope.
10724              When returning, start_decl expects it as NULL_TREE,
10725              and will then then set it using pushdecl. */
10726           my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 980404);
10727           if (current_class_type)
10728             DECL_CONTEXT (decl) = current_class_type;
10729           else
10730             DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
10731
10732           DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
10733           DECL_ASSEMBLER_NAME (decl)
10734             = get_identifier (build_overload_name (type, 1, 1));
10735           DECL_CONTEXT (decl) = NULL_TREE;
10736
10737           /* FIXME remangle member functions; member functions of a
10738              type with external linkage have external linkage.  */
10739         }
10740
10741       if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
10742         {
10743           cp_error_at ("typedef name may not be class-qualified", decl);
10744           return NULL_TREE;
10745         }
10746       else if (quals)
10747         {
10748           if (ctype == NULL_TREE)
10749             {
10750               if (TREE_CODE (type) != METHOD_TYPE)
10751                 cp_error_at ("invalid type qualifier for non-method type", decl);
10752               else
10753                 ctype = TYPE_METHOD_BASETYPE (type);
10754             }
10755           if (ctype != NULL_TREE)
10756             grok_method_quals (ctype, decl, quals);
10757         }
10758
10759       if (RIDBIT_SETP (RID_SIGNED, specbits)
10760           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
10761         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
10762
10763       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
10764                       inlinep, friendp, raises != NULL_TREE);
10765
10766       if (initialized)
10767         error ("typedef declaration includes an initializer");
10768
10769       return decl;
10770     }
10771
10772   /* Detect the case of an array type of unspecified size
10773      which came, as such, direct from a typedef name.
10774      We must copy the type, so that each identifier gets
10775      a distinct type, so that each identifier's size can be
10776      controlled separately by its own initializer.  */
10777
10778   if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
10779       && TYPE_DOMAIN (type) == NULL_TREE)
10780     {
10781       type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
10782     }
10783
10784   /* If this is a type name (such as, in a cast or sizeof),
10785      compute the type and return it now.  */
10786
10787   if (decl_context == TYPENAME)
10788     {
10789       /* Note that the grammar rejects storage classes
10790          in typenames, fields or parameters.  */
10791       if (type_quals != TYPE_UNQUALIFIED)
10792         type_quals = TYPE_UNQUALIFIED;
10793
10794       /* Special case: "friend class foo" looks like a TYPENAME context.  */
10795       if (friendp)
10796         {
10797           if (type_quals != TYPE_UNQUALIFIED)
10798             {
10799               cp_error ("type qualifiers specified for friend class declaration");
10800               type_quals = TYPE_UNQUALIFIED;
10801             }
10802           if (inlinep)
10803             {
10804               cp_error ("`inline' specified for friend class declaration");
10805               inlinep = 0;
10806             }
10807
10808           /* Only try to do this stuff if we didn't already give up.  */
10809           if (type != integer_type_node)
10810             {
10811               /* A friendly class?  */
10812               if (current_class_type)
10813                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
10814               else
10815                 error ("trying to make class `%s' a friend of global scope",
10816                        TYPE_NAME_STRING (type));
10817               type = void_type_node;
10818             }
10819         }
10820       else if (quals)
10821         {
10822           tree dummy = build_decl (TYPE_DECL, declarator, type);
10823           if (ctype == NULL_TREE)
10824             {
10825               my_friendly_assert (TREE_CODE (type) == METHOD_TYPE, 159);
10826               ctype = TYPE_METHOD_BASETYPE (type);
10827             }
10828           grok_method_quals (ctype, dummy, quals);
10829           type = TREE_TYPE (dummy);
10830         }
10831
10832       return type;
10833     }
10834   else if (declarator == NULL_TREE && decl_context != PARM
10835            && decl_context != CATCHPARM
10836            && TREE_CODE (type) != UNION_TYPE
10837            && ! bitfield)
10838     {
10839       cp_error ("abstract declarator `%T' used as declaration", type);
10840       declarator = make_anon_name ();
10841     }
10842
10843   /* `void' at top level (not within pointer)
10844      is allowed only in typedefs or type names.
10845      We don't complain about parms either, but that is because
10846      a better error message can be made later.  */
10847
10848   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
10849     {
10850       if (! declarator)
10851         error ("unnamed variable or field declared void");
10852       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10853         {
10854           if (IDENTIFIER_OPNAME_P (declarator))
10855             my_friendly_abort (356);
10856           else
10857             error ("variable or field `%s' declared void", name);
10858         }
10859       else
10860         error ("variable or field declared void");
10861       type = integer_type_node;
10862     }
10863
10864   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
10865      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
10866
10867   if (decl_context == PARM || decl_context == CATCHPARM)
10868     {
10869       if (ctype || in_namespace)
10870         error ("cannot use `::' in parameter declaration");
10871
10872       /* A parameter declared as an array of T is really a pointer to T.
10873          One declared as a function is really a pointer to a function.
10874          One declared as a member is really a pointer to member.  */
10875
10876       if (TREE_CODE (type) == ARRAY_TYPE)
10877         {
10878           /* Transfer const-ness of array into that of type pointed to.  */
10879           type = build_pointer_type (TREE_TYPE (type));
10880           type_quals = TYPE_UNQUALIFIED;
10881         }
10882       else if (TREE_CODE (type) == FUNCTION_TYPE)
10883         type = build_pointer_type (type);
10884       else if (TREE_CODE (type) == OFFSET_TYPE)
10885         type = build_pointer_type (type);
10886       else if (TREE_CODE (type) == VOID_TYPE && declarator)
10887         {
10888           error ("declaration of `%s' as void", name);
10889           return NULL_TREE;
10890         }
10891     }
10892
10893   {
10894     register tree decl;
10895
10896     if (decl_context == PARM)
10897       {
10898         decl = build_decl (PARM_DECL, declarator, type);
10899
10900         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
10901                         inlinep, friendp, raises != NULL_TREE);
10902
10903         /* Compute the type actually passed in the parmlist,
10904            for the case where there is no prototype.
10905            (For example, shorts and chars are passed as ints.)
10906            When there is a prototype, this is overridden later.  */
10907
10908         DECL_ARG_TYPE (decl) = type_promotes_to (type);
10909       }
10910     else if (decl_context == FIELD)
10911       {
10912         if (type == error_mark_node)
10913           {
10914             /* Happens when declaring arrays of sizes which
10915                are error_mark_node, for example.  */
10916             decl = NULL_TREE;
10917           }
10918         else if (in_namespace && !friendp)
10919           {
10920             /* Something like struct S { int N::j; };  */
10921             cp_error ("invalid use of `::'");
10922             decl = NULL_TREE;
10923           }
10924         else if (TREE_CODE (type) == FUNCTION_TYPE)
10925           {
10926             int publicp = 0;
10927             tree function_context;
10928
10929             /* We catch the others as conflicts with the builtin
10930                typedefs.  */
10931             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
10932               {
10933                 cp_error ("function `%D' cannot be declared friend",
10934                           declarator);
10935                 friendp = 0;
10936               }
10937
10938             if (friendp == 0)
10939               {
10940                 if (ctype == NULL_TREE)
10941                   ctype = current_class_type;
10942
10943                 if (ctype == NULL_TREE)
10944                   {
10945                     cp_error ("can't make `%D' into a method -- not in a class",
10946                               declarator);
10947                     return void_type_node;
10948                   }
10949
10950                 /* ``A union may [ ... ] not [ have ] virtual functions.''
10951                    ARM 9.5 */
10952                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
10953                   {
10954                     cp_error ("function `%D' declared virtual inside a union",
10955                               declarator);
10956                     return void_type_node;
10957                   }
10958
10959                 if (declarator == ansi_opname[(int) NEW_EXPR]
10960                     || declarator == ansi_opname[(int) VEC_NEW_EXPR]
10961                     || declarator == ansi_opname[(int) DELETE_EXPR]
10962                     || declarator == ansi_opname[(int) VEC_DELETE_EXPR])
10963                   {
10964                     if (virtualp)
10965                       {
10966                         cp_error ("`%D' cannot be declared virtual, since it is always static",
10967                                   declarator);
10968                         virtualp = 0;
10969                       }
10970                   }
10971                 else if (staticp < 2)
10972                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
10973                                                   TYPE_ARG_TYPES (type));
10974               }
10975
10976             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
10977             function_context = (ctype != NULL_TREE) ?
10978               hack_decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
10979             publicp = (! friendp || ! staticp)
10980               && function_context == NULL_TREE;
10981             decl = grokfndecl (ctype, type,
10982                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
10983                                ? declarator : dname,
10984                                declarator,
10985                                virtualp, flags, quals, raises,
10986                                friendp ? -1 : 0, friendp, publicp, inlinep,
10987                                funcdef_flag, template_count, in_namespace);
10988             if (decl == NULL_TREE)
10989               return decl;
10990 #if 0
10991             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
10992             /* The decl and setting of decl_machine_attr is also turned off.  */
10993             decl = build_decl_attribute_variant (decl, decl_machine_attr);
10994 #endif
10995
10996             /* [class.conv.ctor]
10997
10998                A constructor declared without the function-specifier
10999                explicit that can be called with a single parameter
11000                specifies a conversion from the type of its first
11001                parameter to the type of its class.  Such a constructor
11002                is called a converting constructor.  */
11003             if (explicitp == 2)
11004               DECL_NONCONVERTING_P (decl) = 1;
11005             else if (DECL_CONSTRUCTOR_P (decl))
11006               {
11007                 /* The constructor can be called with exactly one
11008                    parameter if there is at least one parameter, and
11009                    any subsequent parameters have default arguments.
11010                    We don't look at the first parameter, which is
11011                    really just the `this' parameter for the new
11012                    object.  */
11013                 tree arg_types =
11014                   TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)));
11015
11016                 /* Skip the `in_chrg' argument too, if present.  */
11017                 if (TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (decl)))
11018                   arg_types = TREE_CHAIN (arg_types);
11019
11020                 if (arg_types == void_list_node
11021                     || (arg_types
11022                         && TREE_CHAIN (arg_types)
11023                         && TREE_CHAIN (arg_types) != void_list_node
11024                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11025                   DECL_NONCONVERTING_P (decl) = 1;
11026               }
11027           }
11028         else if (TREE_CODE (type) == METHOD_TYPE)
11029           {
11030             /* We only get here for friend declarations of
11031                members of other classes.  */
11032             /* All method decls are public, so tell grokfndecl to set
11033                TREE_PUBLIC, also.  */
11034             decl = grokfndecl (ctype, type, declarator, declarator,
11035                                virtualp, flags, quals, raises,
11036                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11037                                template_count, in_namespace);
11038             if (decl == NULL_TREE)
11039               return NULL_TREE;
11040           }
11041         else if (!staticp && ! processing_template_decl
11042                  && TYPE_SIZE (complete_type (type)) == NULL_TREE
11043                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11044           {
11045             if (declarator)
11046               cp_error ("field `%D' has incomplete type", declarator);
11047             else
11048               cp_error ("name `%T' has incomplete type", type);
11049
11050             /* If we're instantiating a template, tell them which
11051                instantiation made the field's type be incomplete.  */
11052             if (current_class_type
11053                 && TYPE_NAME (current_class_type)
11054                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11055                 && declspecs && TREE_VALUE (declspecs)
11056                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11057               cp_error ("  in instantiation of template `%T'",
11058                         current_class_type);
11059
11060             type = error_mark_node;
11061             decl = NULL_TREE;
11062           }
11063         else
11064           {
11065             if (friendp)
11066               {
11067                 error ("`%s' is neither function nor method; cannot be declared friend",
11068                        IDENTIFIER_POINTER (declarator));
11069                 friendp = 0;
11070               }
11071             decl = NULL_TREE;
11072           }
11073
11074         if (friendp)
11075           {
11076             /* Friends are treated specially.  */
11077             if (ctype == current_class_type)
11078               warning ("member functions are implicitly friends of their class");
11079             else
11080               {
11081                 tree t = NULL_TREE;
11082                 if (decl && DECL_NAME (decl))
11083                   {
11084                     if (template_class_depth (current_class_type) == 0)
11085                       {
11086                         decl
11087                           = check_explicit_specialization
11088                           (declarator, decl,
11089                            template_count, 2 * (funcdef_flag != 0) + 4);
11090                         if (decl == error_mark_node)
11091                           return error_mark_node;
11092                       }
11093
11094                     t = do_friend (ctype, declarator, decl,
11095                                    last_function_parms, attrlist, flags, quals,
11096                                    funcdef_flag);
11097                   }
11098                 if (t && funcdef_flag)
11099                   return t;
11100
11101                 return void_type_node;
11102               }
11103           }
11104
11105         /* Structure field.  It may not be a function, except for C++ */
11106
11107         if (decl == NULL_TREE)
11108           {
11109             if (initialized)
11110               {
11111                 if (!staticp)
11112                   {
11113                     /* An attempt is being made to initialize a non-static
11114                        member.  But, from [class.mem]:
11115
11116                        4 A member-declarator can contain a
11117                        constant-initializer only if it declares a static
11118                        member (_class.static_) of integral or enumeration
11119                        type, see _class.static.data_.
11120
11121                        This used to be relatively common practice, but
11122                        the rest of the compiler does not correctly
11123                        handle the initialization unless the member is
11124                        static so we make it static below.  */
11125                     cp_pedwarn ("ANSI C++ forbids initialization of member `%D'",
11126                                 declarator);
11127                     cp_pedwarn ("making `%D' static", declarator);
11128                     staticp = 1;
11129                   }
11130
11131                 if (uses_template_parms (type))
11132                   /* We'll check at instantiation time.  */
11133                   ;
11134                 else if (check_static_variable_definition (declarator,
11135                                                            type))
11136                   /* If we just return the declaration, crashes
11137                      will sometimes occur.  We therefore return
11138                      void_type_node, as if this was a friend
11139                      declaration, to cause callers to completely
11140                      ignore this declaration.  */
11141                   return void_type_node;
11142               }
11143
11144             /* 9.2p13 [class.mem] */
11145             if (declarator == constructor_name (current_class_type)
11146                 /* Divergence from the standard:  In extern "C", we
11147                    allow non-static data members here, because C does
11148                    and /usr/include/netinet/in.h uses that.  */
11149                 && (staticp || ! in_system_header))
11150               cp_pedwarn ("ANSI C++ forbids data member `%D' with same name as enclosing class",
11151                           declarator);
11152
11153             if (staticp)
11154               {
11155                 /* C++ allows static class members.  All other work
11156                    for this is done by grokfield.  */
11157                 decl = build_lang_decl (VAR_DECL, declarator, type);
11158                 TREE_STATIC (decl) = 1;
11159                 /* In class context, 'static' means public access.  */
11160                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11161               }
11162             else
11163               {
11164                 decl = build_lang_decl (FIELD_DECL, declarator, type);
11165                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11166                   {
11167                     DECL_MUTABLE_P (decl) = 1;
11168                     RIDBIT_RESET (RID_MUTABLE, specbits);
11169                   }
11170               }
11171
11172             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11173                             inlinep, friendp, raises != NULL_TREE);
11174           }
11175       }
11176     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11177       {
11178         tree original_name;
11179         int publicp = 0;
11180
11181         if (! declarator)
11182           return NULL_TREE;
11183
11184         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11185           original_name = dname;
11186         else
11187           original_name = declarator;
11188
11189         if (RIDBIT_SETP (RID_AUTO, specbits))
11190           error ("storage class `auto' invalid for function `%s'", name);
11191         else if (RIDBIT_SETP (RID_REGISTER, specbits))
11192           error ("storage class `register' invalid for function `%s'", name);
11193
11194         /* Function declaration not at top level.
11195            Storage classes other than `extern' are not allowed
11196            and `extern' makes no difference.  */
11197         if (! toplevel_bindings_p ()
11198             && (RIDBIT_SETP (RID_STATIC, specbits)
11199                 || RIDBIT_SETP (RID_INLINE, specbits))
11200             && pedantic)
11201           {
11202             if (RIDBIT_SETP (RID_STATIC, specbits))
11203               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11204             else
11205               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11206           }
11207
11208         if (ctype == NULL_TREE)
11209           {
11210             if (virtualp)
11211               {
11212                 error ("virtual non-class function `%s'", name);
11213                 virtualp = 0;
11214               }
11215           }
11216         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11217           type = build_cplus_method_type (ctype, TREE_TYPE (type),
11218                                           TYPE_ARG_TYPES (type));
11219
11220         /* Record presence of `static'.  */
11221         publicp = (ctype != NULL_TREE
11222                    || RIDBIT_SETP (RID_EXTERN, specbits)
11223                    || !RIDBIT_SETP (RID_STATIC, specbits));
11224
11225         decl = grokfndecl (ctype, type, original_name, declarator,
11226                            virtualp, flags, quals, raises,
11227                            1, friendp,
11228                            publicp, inlinep, funcdef_flag,
11229                            template_count, in_namespace);
11230         if (decl == NULL_TREE)
11231           return NULL_TREE;
11232
11233         if (staticp == 1)
11234           {
11235             int illegal_static = 0;
11236
11237             /* Don't allow a static member function in a class, and forbid
11238                declaring main to be static.  */
11239             if (TREE_CODE (type) == METHOD_TYPE)
11240               {
11241                 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11242                 illegal_static = 1;
11243               }
11244             else if (current_function_decl)
11245               {
11246                 /* FIXME need arm citation */
11247                 error ("cannot declare static function inside another function");
11248                 illegal_static = 1;
11249               }
11250
11251             if (illegal_static)
11252               {
11253                 staticp = 0;
11254                 RIDBIT_RESET (RID_STATIC, specbits);
11255               }
11256           }
11257       }
11258     else
11259       {
11260         /* It's a variable.  */
11261
11262         /* An uninitialized decl with `extern' is a reference.  */
11263         decl = grokvardecl (type, declarator, &specbits,
11264                             initialized,
11265                             (type_quals & TYPE_QUAL_CONST) != 0,
11266                             in_namespace);
11267         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11268                         inlinep, friendp, raises != NULL_TREE);
11269
11270         if (ctype)
11271           {
11272             DECL_CONTEXT (decl) = ctype;
11273             if (staticp == 1)
11274               {
11275                 cp_pedwarn ("static member `%D' re-declared as static", decl);
11276                 staticp = 0;
11277                 RIDBIT_RESET (RID_STATIC, specbits);
11278               }
11279             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11280               {
11281                 cp_error ("static member `%D' declared `register'", decl);
11282                 RIDBIT_RESET (RID_REGISTER, specbits);
11283               }
11284             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11285               {
11286                 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11287                             decl);
11288                 RIDBIT_RESET (RID_EXTERN, specbits);
11289               }
11290           }
11291       }
11292
11293     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11294
11295     /* Record `register' declaration for warnings on &
11296        and in case doing stupid register allocation.  */
11297
11298     if (RIDBIT_SETP (RID_REGISTER, specbits))
11299       DECL_REGISTER (decl) = 1;
11300
11301     if (RIDBIT_SETP (RID_EXTERN, specbits))
11302       DECL_THIS_EXTERN (decl) = 1;
11303
11304     if (RIDBIT_SETP (RID_STATIC, specbits))
11305       DECL_THIS_STATIC (decl) = 1;
11306
11307     /* Record constancy and volatility.  There's no need to do this
11308        when processing a template; we'll do this for the instantiated
11309        declaration based on the type of DECL.  */
11310     if (!processing_template_decl)
11311       c_apply_type_quals_to_decl (type_quals, decl);
11312
11313     return decl;
11314   }
11315 }
11316 \f
11317 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11318    An empty exprlist is a parmlist.  An exprlist which
11319    contains only identifiers at the global level
11320    is a parmlist.  Otherwise, it is an exprlist.  */
11321
11322 int
11323 parmlist_is_exprlist (exprs)
11324      tree exprs;
11325 {
11326   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11327     return 0;
11328
11329   if (toplevel_bindings_p ())
11330     {
11331       /* At the global level, if these are all identifiers,
11332          then it is a parmlist.  */
11333       while (exprs)
11334         {
11335           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11336             return 1;
11337           exprs = TREE_CHAIN (exprs);
11338         }
11339       return 0;
11340     }
11341   return 1;
11342 }
11343
11344 /* Subroutine of start_function.  Ensure that each of the parameter
11345    types (as listed in PARMS) is complete, as is required for a
11346    function definition.  */
11347
11348 static void
11349 require_complete_types_for_parms (parms)
11350      tree parms;
11351 {
11352   for (; parms; parms = TREE_CHAIN (parms))
11353     {
11354       tree type = TREE_TYPE (parms);
11355
11356       /* Try to complete the TYPE.  */
11357       type = complete_type (type);
11358
11359       if (type == error_mark_node)
11360         continue;
11361
11362       if (TYPE_SIZE (type) == NULL_TREE)
11363         {
11364           if (DECL_NAME (parms))
11365             error ("parameter `%s' has incomplete type",
11366                    IDENTIFIER_POINTER (DECL_NAME (parms)));
11367           else
11368             error ("parameter has incomplete type");
11369           TREE_TYPE (parms) = error_mark_node;
11370         }
11371       else
11372         layout_decl (parms, 0);
11373     }
11374 }
11375
11376 /* Returns non-zero if T is a local variable.  */
11377
11378 int
11379 local_variable_p (t)
11380      tree t;
11381 {
11382   if ((TREE_CODE (t) == VAR_DECL
11383        /* A VAR_DECL with a context that is a _TYPE is a static data
11384           member.  */
11385        && !TYPE_P (CP_DECL_CONTEXT (t))
11386        /* Any other non-local variable must be at namespace scope.  */
11387        && !DECL_NAMESPACE_SCOPE_P (t))
11388       || (TREE_CODE (t) == PARM_DECL))
11389     return 1;
11390
11391   return 0;
11392 }
11393
11394 /* Returns non-zero if T is an automatic local variable or a label.
11395    (These are the declarations that need to be remapped when the code
11396    containing them is duplicated.)  */
11397
11398 int
11399 nonstatic_local_decl_p (t)
11400      tree t;
11401 {
11402   return ((local_variable_p (t) && !TREE_STATIC (t))
11403           || TREE_CODE (t) == LABEL_DECL
11404           || TREE_CODE (t) == RESULT_DECL);
11405 }
11406
11407 /* Like local_variable_p, but suitable for use as a tree-walking
11408    function.  */
11409
11410 static tree
11411 local_variable_p_walkfn (tp, walk_subtrees, data)
11412      tree *tp;
11413      int *walk_subtrees ATTRIBUTE_UNUSED;
11414      void *data ATTRIBUTE_UNUSED;
11415 {
11416   return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
11417           ? *tp : NULL_TREE);
11418 }
11419
11420 /* Check that ARG, which is a default-argument expression for a
11421    parameter DECL, is legal.  Returns ARG, or ERROR_MARK_NODE, if
11422    something goes wrong.  DECL may also be a _TYPE node, rather than a
11423    DECL, if there is no DECL available.  */
11424
11425 tree
11426 check_default_argument (decl, arg)
11427      tree decl;
11428      tree arg;
11429 {
11430   tree var;
11431   tree decl_type;
11432
11433   if (TREE_CODE (arg) == DEFAULT_ARG)
11434     /* We get a DEFAULT_ARG when looking at an in-class declaration
11435        with a default argument.  Ignore the argument for now; we'll
11436        deal with it after the class is complete.  */
11437     return arg;
11438
11439   if (processing_template_decl || uses_template_parms (arg))
11440     /* We don't do anything checking until instantiation-time.  Note
11441        that there may be uninstantiated arguments even for an
11442        instantiated function, since default arguments are not
11443        instantiated until they are needed.  */
11444     return arg;
11445
11446   if (TYPE_P (decl))
11447     {
11448       decl_type = decl;
11449       decl = NULL_TREE;
11450     }
11451   else
11452     decl_type = TREE_TYPE (decl);
11453
11454   if (arg == error_mark_node
11455       || decl == error_mark_node
11456       || TREE_TYPE (arg) == error_mark_node
11457       || decl_type == error_mark_node)
11458     /* Something already went wrong.  There's no need to check
11459        further.  */
11460     return error_mark_node;
11461
11462   /* [dcl.fct.default]
11463
11464      A default argument expression is implicitly converted to the
11465      parameter type.  */
11466   if (!TREE_TYPE (arg)
11467       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
11468     {
11469       if (decl)
11470         cp_error ("default argument for `%#D' has type `%T'",
11471                   decl, TREE_TYPE (arg));
11472       else
11473         cp_error ("default argument for parameter of type `%T' has type `%T'",
11474                   decl_type, TREE_TYPE (arg));
11475
11476       return error_mark_node;
11477     }
11478
11479   /* [dcl.fct.default]
11480
11481      Local variables shall not be used in default argument
11482      expressions.
11483
11484      The keyword `this' shall not be used in a default argument of a
11485      member function.  */
11486   var = walk_tree (&arg, local_variable_p_walkfn, NULL);
11487   if (var)
11488     {
11489       cp_error ("default argument `%E' uses local variable `%D'",
11490                 arg, var);
11491       return error_mark_node;
11492     }
11493
11494   /* All is well.  */
11495   return arg;
11496 }
11497
11498 /* Decode the list of parameter types for a function type.
11499    Given the list of things declared inside the parens,
11500    return a list of types.
11501
11502    The list we receive can have three kinds of elements:
11503    an IDENTIFIER_NODE for names given without types,
11504    a TREE_LIST node for arguments given as typespecs or names with typespecs,
11505    or void_type_node, to mark the end of an argument list
11506    when additional arguments are not permitted (... was not used).
11507
11508    FUNCDEF_FLAG is nonzero for a function definition, 0 for
11509    a mere declaration.  A nonempty identifier-list gets an error message
11510    when FUNCDEF_FLAG is zero.
11511    If FUNCDEF_FLAG is 1, then parameter types must be complete.
11512    If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
11513
11514    If all elements of the input list contain types,
11515    we return a list of the types.
11516    If all elements contain no type (except perhaps a void_type_node
11517    at the end), we return a null list.
11518    If some have types and some do not, it is an error, and we
11519    return a null list.
11520
11521    Also set last_function_parms to either
11522    a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
11523    A list of names is converted to a chain of PARM_DECLs
11524    by store_parm_decls so that ultimately it is always a chain of decls.
11525
11526    Note that in C++, parameters can take default values.  These default
11527    values are in the TREE_PURPOSE field of the TREE_LIST.  It is
11528    an error to specify default values which are followed by parameters
11529    that have no default values, or an ELLIPSES.  For simplicities sake,
11530    only parameters which are specified with their types can take on
11531    default values.  */
11532
11533 static tree
11534 grokparms (first_parm, funcdef_flag)
11535      tree first_parm;
11536      int funcdef_flag;
11537 {
11538   tree result = NULL_TREE;
11539   tree decls = NULL_TREE;
11540
11541   if (first_parm != NULL_TREE
11542       && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
11543     {
11544       if (! funcdef_flag)
11545         pedwarn ("parameter names (without types) in function declaration");
11546       last_function_parms = first_parm;
11547       return NULL_TREE;
11548     }
11549   else if (first_parm != NULL_TREE
11550            && TREE_CODE (TREE_VALUE (first_parm)) != TREE_LIST
11551            && TREE_CODE (TREE_VALUE (first_parm)) != VOID_TYPE)
11552     my_friendly_abort (145);
11553   else
11554     {
11555       /* Types were specified.  This is a list of declarators
11556          each represented as a TREE_LIST node.  */
11557       register tree parm, chain;
11558       int any_init = 0, any_error = 0;
11559
11560       if (first_parm != NULL_TREE)
11561         {
11562           tree last_result = NULL_TREE;
11563           tree last_decl = NULL_TREE;
11564
11565           for (parm = first_parm; parm != NULL_TREE; parm = chain)
11566             {
11567               tree type = NULL_TREE, list_node = parm;
11568               register tree decl = TREE_VALUE (parm);
11569               tree init = TREE_PURPOSE (parm);
11570
11571               chain = TREE_CHAIN (parm);
11572               /* @@ weak defense against parse errors.  */
11573               if (TREE_CODE (decl) != VOID_TYPE
11574                   && TREE_CODE (decl) != TREE_LIST)
11575                 {
11576                   /* Give various messages as the need arises.  */
11577                   if (TREE_CODE (decl) == STRING_CST)
11578                     cp_error ("invalid string constant `%E'", decl);
11579                   else if (TREE_CODE (decl) == INTEGER_CST)
11580                     error ("invalid integer constant in parameter list, did you forget to give parameter name?");
11581                   continue;
11582                 }
11583
11584               if (TREE_CODE (decl) != VOID_TYPE)
11585                 {
11586                   decl = grokdeclarator (TREE_VALUE (decl),
11587                                          TREE_PURPOSE (decl),
11588                                          PARM, init != NULL_TREE,
11589                                          NULL_TREE);
11590                   if (! decl || TREE_TYPE (decl) == error_mark_node)
11591                     continue;
11592
11593                   /* Top-level qualifiers on the parameters are
11594                      ignored for function types.  */
11595                   type = TYPE_MAIN_VARIANT (TREE_TYPE (decl));
11596
11597                   if (TREE_CODE (type) == VOID_TYPE)
11598                     decl = void_type_node;
11599                   else if (TREE_CODE (type) == METHOD_TYPE)
11600                     {
11601                       if (DECL_NAME (decl))
11602                         /* Cannot use the decl here because
11603                            we don't have DECL_CONTEXT set up yet.  */
11604                         cp_error ("parameter `%D' invalidly declared method type",
11605                                   DECL_NAME (decl));
11606                       else
11607                         error ("parameter invalidly declared method type");
11608                       type = build_pointer_type (type);
11609                       TREE_TYPE (decl) = type;
11610                     }
11611                   else if (TREE_CODE (type) == OFFSET_TYPE)
11612                     {
11613                       if (DECL_NAME (decl))
11614                         cp_error ("parameter `%D' invalidly declared offset type",
11615                                   DECL_NAME (decl));
11616                       else
11617                         error ("parameter invalidly declared offset type");
11618                       type = build_pointer_type (type);
11619                       TREE_TYPE (decl) = type;
11620                     }
11621                   else if (abstract_virtuals_error (decl, type))
11622                     any_error = 1;  /* Seems like a good idea. */
11623                   else if (POINTER_TYPE_P (type))
11624                     {
11625                       tree t = type;
11626                       while (POINTER_TYPE_P (t)
11627                              || (TREE_CODE (t) == ARRAY_TYPE
11628                                  && TYPE_DOMAIN (t) != NULL_TREE))
11629                         t = TREE_TYPE (t);
11630                       if (TREE_CODE (t) == ARRAY_TYPE)
11631                         cp_error ("parameter type `%T' includes %s to array of unknown bound",
11632                                   type,
11633                                   TYPE_PTR_P (type) ? "pointer" : "reference");
11634                     }
11635                 }
11636
11637               if (TREE_CODE (decl) == VOID_TYPE)
11638                 {
11639                   if (result == NULL_TREE)
11640                     {
11641                       result = void_list_node;
11642                       last_result = result;
11643                     }
11644                   else
11645                     {
11646                       TREE_CHAIN (last_result) = void_list_node;
11647                       last_result = void_list_node;
11648                     }
11649                   if (chain
11650                       && (chain != void_list_node || TREE_CHAIN (chain)))
11651                     error ("`void' in parameter list must be entire list");
11652                   break;
11653                 }
11654
11655               /* Since there is a prototype, args are passed in their own types.  */
11656               DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
11657               if (PROMOTE_PROTOTYPES
11658                   && (TREE_CODE (type) == INTEGER_TYPE
11659                       || TREE_CODE (type) == ENUMERAL_TYPE)
11660                   && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
11661                 DECL_ARG_TYPE (decl) = integer_type_node;
11662               if (!any_error && init)
11663                 {
11664                   any_init++;
11665                   init = check_default_argument (decl, init);
11666                 }
11667               else
11668                 init = NULL_TREE;
11669
11670               if (decls == NULL_TREE)
11671                 {
11672                   decls = decl;
11673                   last_decl = decls;
11674                 }
11675               else
11676                 {
11677                   TREE_CHAIN (last_decl) = decl;
11678                   last_decl = decl;
11679                 }
11680               list_node = tree_cons (init, type, NULL_TREE);
11681               if (result == NULL_TREE)
11682                 {
11683                   result = list_node;
11684                   last_result = result;
11685                 }
11686               else
11687                 {
11688                   TREE_CHAIN (last_result) = list_node;
11689                   last_result = list_node;
11690                 }
11691             }
11692           if (last_result)
11693             TREE_CHAIN (last_result) = NULL_TREE;
11694           /* If there are no parameters, and the function does not end
11695              with `...', then last_decl will be NULL_TREE.  */
11696           if (last_decl != NULL_TREE)
11697             TREE_CHAIN (last_decl) = NULL_TREE;
11698         }
11699     }
11700
11701   last_function_parms = decls;
11702
11703   return result;
11704 }
11705
11706 /* Called from the parser to update an element of TYPE_ARG_TYPES for some
11707    FUNCTION_TYPE with the newly parsed version of its default argument, which
11708    was previously digested as text.  See snarf_defarg et al in lex.c.  */
11709
11710 void
11711 replace_defarg (arg, init)
11712      tree arg, init;
11713 {
11714   if (! processing_template_decl
11715       && ! can_convert_arg (TREE_VALUE (arg), TREE_TYPE (init), init))
11716     cp_pedwarn ("invalid type `%T' for default argument to `%T'",
11717                 TREE_TYPE (init), TREE_VALUE (arg));
11718   TREE_PURPOSE (arg) = init;
11719 }
11720 \f
11721 int
11722 copy_args_p (d)
11723      tree d;
11724 {
11725   tree t = FUNCTION_ARG_CHAIN (d);
11726   if (DECL_CONSTRUCTOR_P (d)
11727       && TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (d)))
11728     t = TREE_CHAIN (t);
11729   if (t && TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
11730       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t)))
11731           == DECL_CLASS_CONTEXT (d))
11732       && (TREE_CHAIN (t) == NULL_TREE
11733           || TREE_CHAIN (t) == void_list_node
11734           || TREE_PURPOSE (TREE_CHAIN (t))))
11735     return 1;
11736   return 0;
11737 }
11738
11739 /* These memoizing functions keep track of special properties which
11740    a class may have.  `grok_ctor_properties' notices whether a class
11741    has a constructor of the form X(X&), and also complains
11742    if the class has a constructor of the form X(X).
11743    `grok_op_properties' takes notice of the various forms of
11744    operator= which are defined, as well as what sorts of type conversion
11745    may apply.  Both functions take a FUNCTION_DECL as an argument.  */
11746
11747 int
11748 grok_ctor_properties (ctype, decl)
11749      tree ctype, decl;
11750 {
11751   tree parmtypes = FUNCTION_ARG_CHAIN (decl);
11752   tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
11753
11754   /* When a type has virtual baseclasses, a magical first int argument is
11755      added to any ctor so we can tell if the class has been initialized
11756      yet.  This could screw things up in this function, so we deliberately
11757      ignore the leading int if we're in that situation.  */
11758   if (TYPE_USES_VIRTUAL_BASECLASSES (ctype))
11759     {
11760       my_friendly_assert (parmtypes
11761                           && TREE_VALUE (parmtypes) == integer_type_node,
11762                           980529);
11763       parmtypes = TREE_CHAIN (parmtypes);
11764       parmtype = TREE_VALUE (parmtypes);
11765     }
11766
11767   /* [class.copy]
11768
11769      A non-template constructor for class X is a copy constructor if
11770      its first parameter is of type X&, const X&, volatile X& or const
11771      volatile X&, and either there are no other parameters or else all
11772      other parameters have default arguments.  */
11773   if (TREE_CODE (parmtype) == REFERENCE_TYPE
11774       && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype
11775       && (TREE_CHAIN (parmtypes) == NULL_TREE
11776           || TREE_CHAIN (parmtypes) == void_list_node
11777           || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
11778       && !(DECL_TEMPLATE_INSTANTIATION (decl)
11779            && is_member_template (DECL_TI_TEMPLATE (decl))))
11780     {
11781       TYPE_HAS_INIT_REF (ctype) = 1;
11782       if (CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
11783         TYPE_HAS_CONST_INIT_REF (ctype) = 1;
11784     }
11785   /* [class.copy]
11786
11787      A declaration of a constructor for a class X is ill-formed if its
11788      first parameter is of type (optionally cv-qualified) X and either
11789      there are no other parameters or else all other parameters have
11790      default arguments.
11791
11792      We *don't* complain about member template instantiations that
11793      have this form, though; they can occur as we try to decide what
11794      constructor to use during overload resolution.  Since overload
11795      resolution will never prefer such a constructor to the
11796      non-template copy constructor (which is either explicitly or
11797      implicitly defined), there's no need to worry about their
11798      existence.  Theoretically, they should never even be
11799      instantiated, but that's hard to forestall.  */
11800   else if (TYPE_MAIN_VARIANT (parmtype) == ctype
11801            && (TREE_CHAIN (parmtypes) == NULL_TREE
11802                || TREE_CHAIN (parmtypes) == void_list_node
11803                || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
11804            && !(DECL_TEMPLATE_INSTANTIATION (decl)
11805                 && is_member_template (DECL_TI_TEMPLATE (decl))))
11806     {
11807       cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
11808                 ctype, ctype);
11809       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
11810       return 0;
11811     }
11812   else if (TREE_CODE (parmtype) == VOID_TYPE
11813            || TREE_PURPOSE (parmtypes) != NULL_TREE)
11814     TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
11815
11816   return 1;
11817 }
11818
11819 /* An operator with this name can be either unary or binary.  */
11820
11821 static int
11822 ambi_op_p (name)
11823      tree name;
11824 {
11825   return (name == ansi_opname [(int) INDIRECT_REF]
11826           || name == ansi_opname [(int) ADDR_EXPR]
11827           || name == ansi_opname [(int) NEGATE_EXPR]
11828           || name == ansi_opname[(int) POSTINCREMENT_EXPR]
11829           || name == ansi_opname[(int) POSTDECREMENT_EXPR]
11830           || name == ansi_opname [(int) CONVERT_EXPR]);
11831 }
11832
11833 /* An operator with this name can only be unary.  */
11834
11835 static int
11836 unary_op_p (name)
11837      tree name;
11838 {
11839   return (name == ansi_opname [(int) TRUTH_NOT_EXPR]
11840           || name == ansi_opname [(int) BIT_NOT_EXPR]
11841           || name == ansi_opname [(int) COMPONENT_REF]
11842           || IDENTIFIER_TYPENAME_P (name));
11843 }
11844
11845 /* Do a little sanity-checking on how they declared their operator.  */
11846
11847 void
11848 grok_op_properties (decl, virtualp, friendp)
11849      tree decl;
11850      int virtualp, friendp;
11851 {
11852   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
11853   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
11854   tree name = DECL_NAME (decl);
11855
11856   if (current_class_type == NULL_TREE)
11857     friendp = 1;
11858
11859   if (! friendp)
11860     {
11861       /* [class.copy]
11862
11863          A user-declared copy assignment operator X::operator= is a
11864          non-static non-template member function of class X with
11865          exactly one parameter of type X, X&, const X&, volatile X& or
11866          const volatile X&.  */
11867       if (name == ansi_opname[(int) MODIFY_EXPR]
11868           && !(DECL_TEMPLATE_INSTANTIATION (decl)
11869                && is_member_template (DECL_TI_TEMPLATE (decl))))
11870         ;
11871       else if (name == ansi_opname[(int) CALL_EXPR])
11872         TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
11873       else if (name == ansi_opname[(int) ARRAY_REF])
11874         TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
11875       else if (name == ansi_opname[(int) COMPONENT_REF]
11876                || name == ansi_opname[(int) MEMBER_REF])
11877         TYPE_OVERLOADS_ARROW (current_class_type) = 1;
11878       else if (name == ansi_opname[(int) NEW_EXPR])
11879         TYPE_GETS_NEW (current_class_type) |= 1;
11880       else if (name == ansi_opname[(int) DELETE_EXPR])
11881         TYPE_GETS_DELETE (current_class_type) |= 1;
11882       else if (name == ansi_opname[(int) VEC_NEW_EXPR])
11883         TYPE_GETS_NEW (current_class_type) |= 2;
11884       else if (name == ansi_opname[(int) VEC_DELETE_EXPR])
11885         TYPE_GETS_DELETE (current_class_type) |= 2;
11886     }
11887
11888   if (name == ansi_opname[(int) NEW_EXPR]
11889       || name == ansi_opname[(int) VEC_NEW_EXPR])
11890     {
11891       /* When the compiler encounters the definition of A::operator new, it
11892          doesn't look at the class declaration to find out if it's static.  */
11893       if (methodp)
11894         revert_static_member_fn (&decl, NULL, NULL);
11895
11896       /* Take care of function decl if we had syntax errors.  */
11897       if (argtypes == NULL_TREE)
11898         TREE_TYPE (decl)
11899           = build_function_type (ptr_type_node,
11900                                  hash_tree_chain (integer_type_node,
11901                                                   void_list_node));
11902       else
11903         TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
11904     }
11905   else if (name == ansi_opname[(int) DELETE_EXPR]
11906            || name == ansi_opname[(int) VEC_DELETE_EXPR])
11907     {
11908       if (methodp)
11909         revert_static_member_fn (&decl, NULL, NULL);
11910
11911       if (argtypes == NULL_TREE)
11912         TREE_TYPE (decl)
11913           = build_function_type (void_type_node,
11914                                  hash_tree_chain (ptr_type_node,
11915                                                   void_list_node));
11916       else
11917         {
11918           TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
11919
11920           if (! friendp && name == ansi_opname[(int) VEC_DELETE_EXPR]
11921               && (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)))
11922                   != void_list_node))
11923             TYPE_VEC_DELETE_TAKES_SIZE (current_class_type) = 1;
11924         }
11925     }
11926   else
11927     {
11928       /* An operator function must either be a non-static member function
11929          or have at least one parameter of a class, a reference to a class,
11930          an enumeration, or a reference to an enumeration.  13.4.0.6 */
11931       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
11932         {
11933           if (IDENTIFIER_TYPENAME_P (name)
11934               || name == ansi_opname[(int) CALL_EXPR]
11935               || name == ansi_opname[(int) MODIFY_EXPR]
11936               || name == ansi_opname[(int) COMPONENT_REF]
11937               || name == ansi_opname[(int) ARRAY_REF])
11938             cp_error ("`%D' must be a nonstatic member function", decl);
11939           else
11940             {
11941               tree p = argtypes;
11942
11943               if (DECL_STATIC_FUNCTION_P (decl))
11944                 cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
11945
11946               if (p)
11947                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
11948                   {
11949                     tree arg = TREE_VALUE (p);
11950                     if (TREE_CODE (arg) == REFERENCE_TYPE)
11951                       arg = TREE_TYPE (arg);
11952
11953                     /* This lets bad template code slip through.  */
11954                     if (IS_AGGR_TYPE (arg)
11955                         || TREE_CODE (arg) == ENUMERAL_TYPE
11956                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
11957                         || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
11958                       goto foundaggr;
11959                   }
11960               cp_error
11961                 ("`%D' must have an argument of class or enumerated type",
11962                  decl);
11963             foundaggr:
11964               ;
11965             }
11966         }
11967
11968       if (name == ansi_opname[(int) CALL_EXPR])
11969         return;                 /* No restrictions on args. */
11970
11971       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
11972         {
11973           tree t = TREE_TYPE (name);
11974           if (TREE_CODE (t) == VOID_TYPE)
11975             pedwarn ("void is not a valid type conversion operator");
11976           else if (! friendp)
11977             {
11978               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
11979               const char *what = 0;
11980               if (ref)
11981                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
11982
11983               if (t == current_class_type)
11984                 what = "the same type";
11985               /* Don't force t to be complete here.  */
11986               else if (IS_AGGR_TYPE (t)
11987                        && TYPE_SIZE (t)
11988                        && DERIVED_FROM_P (t, current_class_type))
11989                 what = "a base class";
11990
11991               if (what)
11992                 warning ("conversion to %s%s will never use a type conversion operator",
11993                          ref ? "a reference to " : "", what);
11994             }
11995         }
11996
11997       if (name == ansi_opname[(int) MODIFY_EXPR])
11998         {
11999           tree parmtype;
12000
12001           if (list_length (argtypes) != 3 && methodp)
12002             {
12003               cp_error ("`%D' must take exactly one argument", decl);
12004               return;
12005             }
12006           parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
12007
12008           if (copy_assignment_arg_p (parmtype, virtualp)
12009               && ! friendp)
12010             {
12011               TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
12012               if (TREE_CODE (parmtype) != REFERENCE_TYPE
12013                   || CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12014                 TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
12015             }
12016         }
12017       else if (name == ansi_opname[(int) COND_EXPR])
12018         {
12019           /* 13.4.0.3 */
12020           cp_error ("ANSI C++ prohibits overloading operator ?:");
12021         }
12022       else if (ambi_op_p (name))
12023         {
12024           if (list_length (argtypes) == 2)
12025             /* prefix */;
12026           else if (list_length (argtypes) == 3)
12027             {
12028               if ((name == ansi_opname[(int) POSTINCREMENT_EXPR]
12029                    || name == ansi_opname[(int) POSTDECREMENT_EXPR])
12030                   && ! processing_template_decl
12031                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12032                 {
12033                   if (methodp)
12034                     cp_error ("postfix `%D' must take `int' as its argument",
12035                               decl);
12036                   else
12037                     cp_error
12038                       ("postfix `%D' must take `int' as its second argument",
12039                        decl);
12040                 }
12041             }
12042           else
12043             {
12044               if (methodp)
12045                 cp_error ("`%D' must take either zero or one argument", decl);
12046               else
12047                 cp_error ("`%D' must take either one or two arguments", decl);
12048             }
12049
12050           /* More Effective C++ rule 6.  */
12051           if (warn_ecpp
12052               && (name == ansi_opname[(int) POSTINCREMENT_EXPR]
12053                   || name == ansi_opname[(int) POSTDECREMENT_EXPR]))
12054             {
12055               tree arg = TREE_VALUE (argtypes);
12056               tree ret = TREE_TYPE (TREE_TYPE (decl));
12057               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12058                 arg = TREE_TYPE (arg);
12059               arg = TYPE_MAIN_VARIANT (arg);
12060               if (list_length (argtypes) == 2)
12061                 {
12062                   if (TREE_CODE (ret) != REFERENCE_TYPE
12063                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12064                                        arg))
12065                     cp_warning ("prefix `%D' should return `%T'", decl,
12066                                 build_reference_type (arg));
12067                 }
12068               else
12069                 {
12070                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12071                     cp_warning ("postfix `%D' should return `%T'", decl, arg);
12072                 }
12073             }
12074         }
12075       else if (unary_op_p (name))
12076         {
12077           if (list_length (argtypes) != 2)
12078             {
12079               if (methodp)
12080                 cp_error ("`%D' must take `void'", decl);
12081               else
12082                 cp_error ("`%D' must take exactly one argument", decl);
12083             }
12084         }
12085       else /* if (binary_op_p (name)) */
12086         {
12087           if (list_length (argtypes) != 3)
12088             {
12089               if (methodp)
12090                 cp_error ("`%D' must take exactly one argument", decl);
12091               else
12092                 cp_error ("`%D' must take exactly two arguments", decl);
12093             }
12094
12095           /* More Effective C++ rule 7.  */
12096           if (warn_ecpp
12097               && (name == ansi_opname [TRUTH_ANDIF_EXPR]
12098                   || name == ansi_opname [TRUTH_ORIF_EXPR]
12099                   || name == ansi_opname [COMPOUND_EXPR]))
12100             cp_warning ("user-defined `%D' always evaluates both arguments",
12101                         decl);
12102         }
12103
12104       /* Effective C++ rule 23.  */
12105       if (warn_ecpp
12106           && list_length (argtypes) == 3
12107           && (name == ansi_opname [PLUS_EXPR]
12108               || name == ansi_opname [MINUS_EXPR]
12109               || name == ansi_opname [TRUNC_DIV_EXPR]
12110               || name == ansi_opname [MULT_EXPR])
12111           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12112         cp_warning ("`%D' should return by value", decl);
12113
12114       /* 13.4.0.8 */
12115       if (argtypes)
12116         for (; argtypes != void_list_node ; argtypes = TREE_CHAIN (argtypes))
12117           if (TREE_PURPOSE (argtypes))
12118             {
12119               TREE_PURPOSE (argtypes) = NULL_TREE;
12120               if (name == ansi_opname[(int) POSTINCREMENT_EXPR]
12121                   || name == ansi_opname[(int) POSTDECREMENT_EXPR])
12122                 {
12123                   if (pedantic)
12124                     cp_pedwarn ("`%D' cannot have default arguments", decl);
12125                 }
12126               else
12127                 cp_error ("`%D' cannot have default arguments", decl);
12128             }
12129     }
12130 }
12131 \f
12132 static const char *
12133 tag_name (code)
12134      enum tag_types code;
12135 {
12136   switch (code)
12137     {
12138     case record_type:
12139       return "struct";
12140     case class_type:
12141       return "class";
12142     case union_type:
12143       return "union ";
12144     case enum_type:
12145       return "enum";
12146     default:
12147       my_friendly_abort (981122);
12148     }
12149 }
12150
12151 /* Get the struct, enum or union (CODE says which) with tag NAME.
12152    Define the tag as a forward-reference if it is not defined.
12153
12154    C++: If a class derivation is given, process it here, and report
12155    an error if multiple derivation declarations are not identical.
12156
12157    If this is a definition, come in through xref_tag and only look in
12158    the current frame for the name (since C++ allows new names in any
12159    scope.)  */
12160
12161 tree
12162 xref_tag (code_type_node, name, globalize)
12163      tree code_type_node;
12164      tree name;
12165      int globalize;
12166 {
12167   enum tag_types tag_code;
12168   enum tree_code code;
12169   register tree ref, t;
12170   struct binding_level *b = current_binding_level;
12171   int got_type = 0;
12172   tree attributes = NULL_TREE;
12173   tree context = NULL_TREE;
12174
12175   /* If we are called from the parser, code_type_node will sometimes be a
12176      TREE_LIST.  This indicates that the user wrote
12177      "class __attribute__ ((foo)) bar".  Extract the attributes so we can
12178      use them later.  */
12179   if (TREE_CODE (code_type_node) == TREE_LIST)
12180     {
12181       attributes = TREE_PURPOSE (code_type_node);
12182       code_type_node = TREE_VALUE (code_type_node);
12183     }
12184
12185   tag_code = (enum tag_types) TREE_INT_CST_LOW (code_type_node);
12186   switch (tag_code)
12187     {
12188     case record_type:
12189     case class_type:
12190       code = RECORD_TYPE;
12191       break;
12192     case union_type:
12193       code = UNION_TYPE;
12194       break;
12195     case enum_type:
12196       code = ENUMERAL_TYPE;
12197       break;
12198     default:
12199       my_friendly_abort (18);
12200     }
12201
12202   /* If a cross reference is requested, look up the type
12203      already defined for this tag and return it.  */
12204   if (TREE_CODE_CLASS (TREE_CODE (name)) == 't')
12205     {
12206       t = name;
12207       name = TYPE_IDENTIFIER (t);
12208       got_type = 1;
12209     }
12210   else
12211     t = IDENTIFIER_TYPE_VALUE (name);
12212
12213   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12214       && TREE_CODE (t) != TEMPLATE_TEMPLATE_PARM)
12215     t = NULL_TREE;
12216
12217   if (! globalize)
12218     {
12219       /* If we know we are defining this tag, only look it up in
12220          this scope and don't try to find it as a type.  */
12221       ref = lookup_tag (code, name, b, 1);
12222     }
12223   else
12224     {
12225       if (t)
12226         {
12227           /* [dcl.type.elab] If the identifier resolves to a
12228              typedef-name or a template type-parameter, the
12229              elaborated-type-specifier is ill-formed.  */
12230           if (t != TYPE_MAIN_VARIANT (t)
12231               || (CLASS_TYPE_P (t) && TYPE_WAS_ANONYMOUS (t)))
12232             cp_pedwarn ("using typedef-name `%D' after `%s'",
12233                         TYPE_NAME (t), tag_name (tag_code));
12234           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12235             cp_error ("using template type parameter `%T' after `%s'",
12236                       t, tag_name (tag_code));
12237
12238           ref = t;
12239         }
12240       else
12241         ref = lookup_tag (code, name, b, 0);
12242
12243       if (! ref)
12244         {
12245           /* Try finding it as a type declaration.  If that wins,
12246              use it.  */
12247           ref = lookup_name (name, 1);
12248
12249           if (ref != NULL_TREE
12250               && processing_template_decl
12251               && DECL_CLASS_TEMPLATE_P (ref)
12252               && template_class_depth (current_class_type) == 0)
12253             /* Since GLOBALIZE is true, we're declaring a global
12254                template, so we want this type.  */
12255             ref = DECL_RESULT (ref);
12256
12257           if (ref && TREE_CODE (ref) == TYPE_DECL
12258               && TREE_CODE (TREE_TYPE (ref)) == code)
12259             ref = TREE_TYPE (ref);
12260           else
12261             ref = NULL_TREE;
12262         }
12263
12264       if (ref && current_class_type
12265           && template_class_depth (current_class_type)
12266           && PROCESSING_REAL_TEMPLATE_DECL_P ())
12267         {
12268           /* Since GLOBALIZE is non-zero, we are not looking at a
12269              definition of this tag.  Since, in addition, we are currently
12270              processing a (member) template declaration of a template
12271              class, we must be very careful; consider:
12272
12273                template <class X>
12274                struct S1
12275
12276                template <class U>
12277                struct S2
12278                { template <class V>
12279                friend struct S1; };
12280
12281              Here, the S2::S1 declaration should not be confused with the
12282              outer declaration.  In particular, the inner version should
12283              have a template parameter of level 2, not level 1.  This
12284              would be particularly important if the member declaration
12285              were instead:
12286
12287                template <class V = U> friend struct S1;
12288
12289              say, when we should tsubst into `U' when instantiating
12290              S2.  On the other hand, when presented with:
12291
12292                  template <class T>
12293                  struct S1 {
12294                    template <class U>
12295                    struct S2 {};
12296                    template <class U>
12297                    friend struct S2;
12298                  };
12299
12300               we must find the inner binding eventually.  We
12301               accomplish this by making sure that the new type we
12302               create to represent this declaration has the right
12303               TYPE_CONTEXT.  */
12304           context = TYPE_CONTEXT (ref);
12305           ref = NULL_TREE;
12306         }
12307     }
12308
12309   if (! ref)
12310     {
12311       /* If no such tag is yet defined, create a forward-reference node
12312          and record it as the "definition".
12313          When a real declaration of this type is found,
12314          the forward-reference will be altered into a real type.  */
12315       if (code == ENUMERAL_TYPE)
12316         {
12317           cp_error ("use of enum `%#D' without previous declaration", name);
12318
12319           ref = make_node (ENUMERAL_TYPE);
12320
12321           /* Give the type a default layout like unsigned int
12322              to avoid crashing if it does not get defined.  */
12323           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12324           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12325           TREE_UNSIGNED (ref) = 1;
12326           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12327           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12328           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12329
12330           /* Enable us to recognize when a type is created in class context.
12331              To do nested classes correctly, this should probably be cleared
12332              out when we leave this classes scope.  Currently this in only
12333              done in `start_enum'.  */
12334
12335           pushtag (name, ref, globalize);
12336         }
12337       else
12338         {
12339           struct binding_level *old_b = class_binding_level;
12340
12341           ref = make_aggr_type (code);
12342           TYPE_CONTEXT (ref) = context;
12343
12344 #ifdef NONNESTED_CLASSES
12345           /* Class types don't nest the way enums do.  */
12346           class_binding_level = (struct binding_level *)0;
12347 #endif
12348           pushtag (name, ref, globalize);
12349           class_binding_level = old_b;
12350         }
12351     }
12352   else
12353     {
12354       /* If it no longer looks like a nested type, make sure it's
12355          in global scope.
12356          If it is not an IDENTIFIER, this is not a declaration */
12357       if (b->namespace_p && !class_binding_level
12358           && TREE_CODE (name) == IDENTIFIER_NODE
12359           && IDENTIFIER_NAMESPACE_VALUE (name) == NULL_TREE)
12360         SET_IDENTIFIER_NAMESPACE_VALUE (name, TYPE_NAME (ref));
12361
12362       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12363         redeclare_class_template (ref, current_template_parms);
12364     }
12365
12366   /* Until the type is defined, tentatively accept whatever
12367      structure tag the user hands us.  */
12368   if (TYPE_SIZE (ref) == NULL_TREE
12369       && ref != current_class_type
12370       /* Have to check this, in case we have contradictory tag info.  */
12371       && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
12372     {
12373       if (tag_code == class_type)
12374         CLASSTYPE_DECLARED_CLASS (ref) = 1;
12375       else if (tag_code == record_type)
12376         CLASSTYPE_DECLARED_CLASS (ref) = 0;
12377     }
12378
12379   TREE_TYPE (ref) = attributes;
12380
12381   return ref;
12382 }
12383
12384 tree
12385 xref_tag_from_type (old, id, globalize)
12386      tree old, id;
12387      int globalize;
12388 {
12389   tree code_type_node;
12390
12391   if (TREE_CODE (old) == RECORD_TYPE)
12392     code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
12393                       ? class_type_node : record_type_node);
12394   else
12395     code_type_node = union_type_node;
12396
12397   if (id == NULL_TREE)
12398     id = TYPE_IDENTIFIER (old);
12399
12400   return xref_tag (code_type_node, id, globalize);
12401 }
12402
12403 /* REF is a type (named NAME), for which we have just seen some
12404    baseclasses.  BINFO is a list of those baseclasses; the
12405    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12406    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
12407    struct, or union.  */
12408
12409 void
12410 xref_basetypes (code_type_node, name, ref, binfo)
12411      tree code_type_node;
12412      tree name, ref;
12413      tree binfo;
12414 {
12415   /* In the declaration `A : X, Y, ... Z' we mark all the types
12416      (A, X, Y, ..., Z) so we can check for duplicates.  */
12417   tree binfos;
12418   tree base;
12419
12420   int i, len;
12421   enum tag_types tag_code = (enum tag_types) TREE_INT_CST_LOW (code_type_node);
12422
12423   if (tag_code == union_type)
12424     {
12425       cp_error ("derived union `%T' invalid", ref);
12426       return;
12427     }
12428
12429   len = list_length (binfo);
12430
12431   /* First, make sure that any templates in base-classes are
12432      instantiated.  This ensures that if we call ourselves recursively
12433      we do not get confused about which classes are marked and which
12434      are not.  */
12435   for (base = binfo; base; base = TREE_CHAIN (base))
12436     complete_type (TREE_VALUE (base));
12437
12438   SET_CLASSTYPE_MARKED (ref);
12439   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
12440
12441   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
12442     {
12443       /* The base of a derived struct is public by default.  */
12444       int via_public
12445         = (TREE_PURPOSE (binfo) == access_public_node
12446            || TREE_PURPOSE (binfo) == access_public_virtual_node
12447            || (tag_code != class_type
12448                && (TREE_PURPOSE (binfo) == access_default_node
12449                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
12450       int via_protected
12451         = (TREE_PURPOSE (binfo) == access_protected_node
12452            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
12453       int via_virtual
12454         = (TREE_PURPOSE (binfo) == access_private_virtual_node
12455            || TREE_PURPOSE (binfo) == access_protected_virtual_node
12456            || TREE_PURPOSE (binfo) == access_public_virtual_node
12457            || TREE_PURPOSE (binfo) == access_default_virtual_node);
12458       tree basetype = TREE_VALUE (binfo);
12459       tree base_binfo;
12460
12461       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
12462         basetype = TREE_TYPE (basetype);
12463       if (!basetype
12464           || (TREE_CODE (basetype) != RECORD_TYPE
12465               && TREE_CODE (basetype) != TYPENAME_TYPE
12466               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
12467               && TREE_CODE (basetype) != TEMPLATE_TEMPLATE_PARM))
12468         {
12469           cp_error ("base type `%T' fails to be a struct or class type",
12470                     TREE_VALUE (binfo));
12471           continue;
12472         }
12473
12474       GNU_xref_hier (name, basetype, via_public, via_virtual, 0);
12475
12476       /* This code replaces similar code in layout_basetypes.
12477          We put the complete_type first for implicit `typename'.  */
12478       if (TYPE_SIZE (basetype) == NULL_TREE
12479           && ! (current_template_parms && uses_template_parms (basetype)))
12480         {
12481           cp_error ("base class `%T' has incomplete type", basetype);
12482           continue;
12483         }
12484       else
12485         {
12486           if (CLASSTYPE_MARKED (basetype))
12487             {
12488               if (basetype == ref)
12489                 cp_error ("recursive type `%T' undefined", basetype);
12490               else
12491                 cp_error ("duplicate base type `%T' invalid", basetype);
12492               continue;
12493             }
12494
12495           if (TYPE_FOR_JAVA (basetype)
12496               && (current_lang_stack
12497                   == &VARRAY_TREE (current_lang_base, 0)))
12498             TYPE_FOR_JAVA (ref) = 1;
12499
12500           /* Note that the BINFO records which describe individual
12501              inheritances are *not* shared in the lattice!  They
12502              cannot be shared because a given baseclass may be
12503              inherited with different `accessibility' by different
12504              derived classes.  (Each BINFO record describing an
12505              individual inheritance contains flags which say what
12506              the `accessibility' of that particular inheritance is.)  */
12507
12508           base_binfo
12509             = make_binfo (integer_zero_node, basetype,
12510                           CLASS_TYPE_P (basetype)
12511                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
12512                           CLASS_TYPE_P (basetype)
12513                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
12514
12515           TREE_VEC_ELT (binfos, i) = base_binfo;
12516           TREE_VIA_PUBLIC (base_binfo) = via_public;
12517           TREE_VIA_PROTECTED (base_binfo) = via_protected;
12518           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
12519           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
12520
12521           /* We need to unshare the binfos now so that lookups during class
12522              definition work.  */
12523           unshare_base_binfos (base_binfo);
12524
12525           SET_CLASSTYPE_MARKED (basetype);
12526
12527           /* We are free to modify these bits because they are meaningless
12528              at top level, and BASETYPE is a top-level type.  */
12529           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
12530             {
12531               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
12532               /* Converting to a virtual base class requires looking
12533                  up the offset of the virtual base.  */
12534               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12535             }
12536
12537           if (CLASS_TYPE_P (basetype))
12538             {
12539               TYPE_GETS_NEW (ref) |= TYPE_GETS_NEW (basetype);
12540               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
12541               /* If the base-class uses multiple inheritance, so do we.  */
12542               TYPE_USES_MULTIPLE_INHERITANCE (ref)
12543                 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
12544               /* Likewise, if converting to a base of the base may require
12545                  code, then we may need to generate code to convert to a
12546                  base as well.  */
12547               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
12548                 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
12549             }
12550
12551           i += 1;
12552         }
12553     }
12554   if (i)
12555     TREE_VEC_LENGTH (binfos) = i;
12556   else
12557     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
12558
12559   if (i > 1)
12560     {
12561       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
12562       /* If there is more than one non-empty they cannot be at the same
12563          address.  */
12564       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12565     }
12566
12567   /* Unmark all the types.  */
12568   while (--i >= 0)
12569     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
12570   CLEAR_CLASSTYPE_MARKED (ref);
12571
12572   /* Now that we know all the base-classes, set up the list of virtual
12573      bases.  */
12574   get_vbase_types (ref);
12575 }
12576
12577 \f
12578 /* Begin compiling the definition of an enumeration type.
12579    NAME is its name (or null if anonymous).
12580    Returns the type object, as yet incomplete.
12581    Also records info about it so that build_enumerator
12582    may be used to declare the individual values as they are read.  */
12583
12584 tree
12585 start_enum (name)
12586      tree name;
12587 {
12588   register tree enumtype = NULL_TREE;
12589   struct binding_level *b = current_binding_level;
12590
12591   /* If this is the real definition for a previous forward reference,
12592      fill in the contents in the same object that used to be the
12593      forward reference.  */
12594
12595   if (name != NULL_TREE)
12596     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
12597
12598   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
12599     {
12600       cp_error ("multiple definition of `%#T'", enumtype);
12601       cp_error_at ("previous definition here", enumtype);
12602       /* Clear out TYPE_VALUES, and start again.  */
12603       TYPE_VALUES (enumtype) = NULL_TREE;
12604     }
12605   else
12606     {
12607       enumtype = make_node (ENUMERAL_TYPE);
12608       pushtag (name, enumtype, 0);
12609     }
12610
12611   if (current_class_type)
12612     TREE_ADDRESSABLE (b->tags) = 1;
12613
12614   GNU_xref_decl (current_function_decl, enumtype);
12615   return enumtype;
12616 }
12617
12618 /* After processing and defining all the values of an enumeration type,
12619    install their decls in the enumeration type and finish it off.
12620    ENUMTYPE is the type object and VALUES a list of name-value pairs.
12621    Returns ENUMTYPE.  */
12622
12623 tree
12624 finish_enum (enumtype)
12625      tree enumtype;
12626 {
12627   register tree minnode = NULL_TREE, maxnode = NULL_TREE;
12628   /* Calculate the maximum value of any enumerator in this type.  */
12629
12630   tree values = TYPE_VALUES (enumtype);
12631   if (values)
12632     {
12633       tree pair;
12634
12635       for (pair = values; pair; pair = TREE_CHAIN (pair))
12636         {
12637           tree decl;
12638           tree value;
12639
12640           /* The TREE_VALUE is a CONST_DECL for this enumeration
12641              constant.  */
12642           decl = TREE_VALUE (pair);
12643
12644           /* [dcl.enum]
12645
12646              Following the closing brace of an enum-specifier, each
12647              enumerator has the type of its enumeration.  Prior to the
12648              closing brace, the type of each enumerator is the type of
12649              its initializing value.  */
12650           TREE_TYPE (decl) = enumtype;
12651
12652           /* The DECL_INITIAL will be NULL if we are processing a
12653              template declaration and this enumeration constant had no
12654              explicit initializer.  */
12655           value = DECL_INITIAL (decl);
12656           if (value && !processing_template_decl)
12657             {
12658               /* Set the TREE_TYPE for the VALUE as well.  That's so
12659                  that when we call decl_constant_value we get an
12660                  entity of the right type (but with the constant
12661                  value).  Since we shouldn't ever call
12662                  decl_constant_value on a template type, there's no
12663                  reason to do that when processing_template_decl.
12664                  And, if the expression is something like a
12665                  TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will
12666                  wreak havoc on the intended type of the expression.
12667
12668                  Of course, there's also no point in trying to compute
12669                  minimum or maximum values if we're in a template.  */
12670               TREE_TYPE (value) = enumtype;
12671
12672               if (!minnode)
12673                 minnode = maxnode = value;
12674               else if (tree_int_cst_lt (maxnode, value))
12675                 maxnode = value;
12676               else if (tree_int_cst_lt (value, minnode))
12677                 minnode = value;
12678             }
12679
12680           if (processing_template_decl)
12681             /* If this is just a template, leave the CONST_DECL
12682                alone.  That way tsubst_copy will find CONST_DECLs for
12683                CONST_DECLs, and not INTEGER_CSTs.  */
12684             ;
12685           else
12686             /* In the list we're building up, we want the enumeration
12687                values, not the CONST_DECLs.  */
12688             TREE_VALUE (pair) = value;
12689         }
12690     }
12691   else
12692     maxnode = minnode = integer_zero_node;
12693
12694   TYPE_VALUES (enumtype) = nreverse (values);
12695
12696   if (processing_template_decl)
12697     {
12698       tree scope = current_scope ();
12699       if (scope && TREE_CODE (scope) == FUNCTION_DECL)
12700         add_tree (build_min (TAG_DEFN, enumtype));
12701     }
12702   else
12703     {
12704       int unsignedp = tree_int_cst_sgn (minnode) >= 0;
12705       int lowprec = min_precision (minnode, unsignedp);
12706       int highprec = min_precision (maxnode, unsignedp);
12707       int precision = MAX (lowprec, highprec);
12708       tree tem;
12709
12710       TYPE_SIZE (enumtype) = NULL_TREE;
12711
12712       /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
12713
12714       TYPE_PRECISION (enumtype) = precision;
12715       if (unsignedp)
12716         fixup_unsigned_type (enumtype);
12717       else
12718         fixup_signed_type (enumtype);
12719
12720       if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
12721         /* Use the width of the narrowest normal C type which is wide
12722            enough.  */
12723         TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
12724                                                     (precision, 1));
12725       else
12726         TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
12727
12728       TYPE_SIZE (enumtype) = 0;
12729       layout_type (enumtype);
12730
12731       /* Fix up all variant types of this enum type.  */
12732       for (tem = TYPE_MAIN_VARIANT (enumtype); tem;
12733            tem = TYPE_NEXT_VARIANT (tem))
12734         {
12735           TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
12736           TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
12737           TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
12738           TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
12739           TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
12740           TYPE_MODE (tem) = TYPE_MODE (enumtype);
12741           TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
12742           TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
12743           TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
12744         }
12745
12746       /* Finish debugging output for this type.  */
12747       rest_of_type_compilation (enumtype, namespace_bindings_p ());
12748     }
12749
12750   return enumtype;
12751 }
12752
12753 /* Build and install a CONST_DECL for an enumeration constant of the
12754    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
12755    Assignment of sequential values by default is handled here.  */
12756
12757 void
12758 build_enumerator (name, value, enumtype)
12759      tree name;
12760      tree value;
12761      tree enumtype;
12762 {
12763   tree decl;
12764   tree context;
12765   tree type;
12766   tree values;
12767
12768   /* Remove no-op casts from the value.  */
12769   if (value)
12770     STRIP_TYPE_NOPS (value);
12771
12772   if (! processing_template_decl)
12773     {
12774       /* Validate and default VALUE.  */
12775       if (value != NULL_TREE)
12776         {
12777           if (TREE_READONLY_DECL_P (value))
12778             value = decl_constant_value (value);
12779
12780           if (TREE_CODE (value) == INTEGER_CST)
12781             {
12782               value = default_conversion (value);
12783               constant_expression_warning (value);
12784             }
12785           else
12786             {
12787               cp_error ("enumerator value for `%D' not integer constant", name);
12788               value = NULL_TREE;
12789             }
12790         }
12791
12792       /* Default based on previous value.  */
12793       if (value == NULL_TREE && ! processing_template_decl)
12794         {
12795           tree prev_value;
12796
12797           if (TYPE_VALUES (enumtype))
12798             {
12799               /* The next value is the previous value ... */
12800               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
12801               /* ... plus one.  */
12802               value = build_binary_op_nodefault (PLUS_EXPR,
12803                                                  prev_value,
12804                                                  integer_one_node,
12805                                                  PLUS_EXPR);
12806
12807               if (tree_int_cst_lt (value, prev_value))
12808                 cp_error ("overflow in enumeration values at `%D'", name);
12809             }
12810           else
12811             value = integer_zero_node;
12812         }
12813
12814       /* Remove no-op casts from the value.  */
12815       if (value)
12816         STRIP_TYPE_NOPS (value);
12817 #if 0
12818       /* To fix MAX_VAL enum consts. (bkoz)  */
12819       TREE_TYPE (value) = integer_type_node;
12820 #endif
12821     }
12822
12823   /* We always have to copy here; not all INTEGER_CSTs are unshared.
12824      Even in other cases, we will later (in finish_enum) be setting
12825      the type of VALUE.  But, we don't need to make a copy if this
12826      VALUE is one of the enumeration constants for this same
12827      enumeration type.  */
12828   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
12829     if (TREE_VALUE (values) == value)
12830       break;
12831   /* If we didn't break out of the loop, then we do need a copy.  */
12832   if (!values && value)
12833     value = copy_node (value);
12834
12835   /* C++ associates enums with global, function, or class declarations.  */
12836   context = current_scope ();
12837
12838   /* Build the actual enumeration constant.  Note that the enumeration
12839     constants have the type of their initializers until the
12840     enumeration is complete:
12841
12842       [ dcl.enum ]
12843
12844       Following the closing brace of an enum-specifier, each enumer-
12845       ator has the type of its enumeration.  Prior to the closing
12846       brace, the type of each enumerator is the type of its
12847       initializing value.
12848
12849     In finish_enum we will reset the type.  Of course, if we're
12850     processing a template, there may be no value.   */
12851   type = value ? TREE_TYPE (value) : NULL_TREE;
12852
12853   if (context && context == current_class_type)
12854     /* This enum declaration is local to the class.  We need the full
12855       lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
12856     decl = build_lang_decl (CONST_DECL, name, type);
12857   else
12858     /* It's a global enum, or it's local to a function.  (Note local to
12859       a function could mean local to a class method.  */
12860     decl = build_decl (CONST_DECL, name, type);
12861
12862   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
12863   DECL_INITIAL (decl) = value;
12864   TREE_READONLY (decl) = 1;
12865
12866   if (context && context == current_class_type)
12867     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
12868       on the TYPE_FIELDS list for `S'.  (That's so that you can say
12869       things like `S::i' later.)  */
12870     finish_member_declaration (decl);
12871   else
12872     {
12873       pushdecl (decl);
12874       GNU_xref_decl (current_function_decl, decl);
12875     }
12876
12877   /* Add this enumeration constant to the list for this type.  */
12878   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
12879 }
12880
12881 \f
12882 static int function_depth;
12883
12884 /* We're defining DECL.  Make sure that it's type is OK.  */
12885
12886 static void
12887 check_function_type (decl)
12888      tree decl;
12889 {
12890   tree fntype = TREE_TYPE (decl);
12891
12892   /* In a function definition, arg types must be complete.  */
12893   require_complete_types_for_parms (current_function_parms);
12894
12895   if (TYPE_SIZE (complete_type (TREE_TYPE (fntype))) == NULL_TREE)
12896     {
12897       cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
12898
12899       /* Make it return void instead, but don't change the
12900          type of the DECL_RESULT, in case we have a named return value.  */
12901       if (TREE_CODE (fntype) == METHOD_TYPE)
12902         {
12903           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
12904           TREE_TYPE (decl)
12905             = build_cplus_method_type (ctype,
12906                                        void_type_node,
12907                                        FUNCTION_ARG_CHAIN (decl));
12908         }
12909       else
12910         TREE_TYPE (decl)
12911           = build_function_type (void_type_node,
12912                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
12913       TREE_TYPE (decl)
12914         = build_exception_variant (fntype,
12915                                    TYPE_RAISES_EXCEPTIONS (fntype));
12916     }
12917   else
12918     abstract_virtuals_error (decl, TREE_TYPE (fntype));
12919 }
12920
12921 /* Create the FUNCTION_DECL for a function definition.
12922    DECLSPECS and DECLARATOR are the parts of the declaration;
12923    they describe the function's name and the type it returns,
12924    but twisted together in a fashion that parallels the syntax of C.
12925
12926    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
12927    DECLARATOR is really the DECL for the function we are about to
12928    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
12929    indicating that the function is an inline defined in-class, and
12930    SF_EXPAND indicating that we should generate RTL for this
12931    function.
12932
12933    This function creates a binding context for the function body
12934    as well as setting up the FUNCTION_DECL in current_function_decl.
12935
12936    Returns 1 on success.  If the DECLARATOR is not suitable for a function
12937    (it defines a datum instead), we return 0, which tells
12938    yyparse to report a parse error.
12939
12940    For C++, we must first check whether that datum makes any sense.
12941    For example, "class A local_a(1,2);" means that variable local_a
12942    is an aggregate of type A, which should have a constructor
12943    applied to it with the argument list [1, 2].  */
12944
12945 int
12946 start_function (declspecs, declarator, attrs, flags)
12947      tree declspecs, declarator, attrs;
12948      int flags;
12949 {
12950   tree decl1;
12951   tree ctype = NULL_TREE;
12952   tree fntype;
12953   tree restype;
12954   extern int have_extern_spec;
12955   extern int used_extern_spec;
12956   int doing_friend = 0;
12957   struct binding_level *bl;
12958
12959   /* Sanity check.  */
12960   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
12961   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
12962
12963   /* This should only be done once on the top most decl.  */
12964   if (have_extern_spec && !used_extern_spec)
12965     {
12966       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
12967       used_extern_spec = 1;
12968     }
12969
12970   if (flags & SF_PRE_PARSED)
12971     {
12972       decl1 = declarator;
12973
12974       fntype = TREE_TYPE (decl1);
12975       if (TREE_CODE (fntype) == METHOD_TYPE)
12976         ctype = TYPE_METHOD_BASETYPE (fntype);
12977
12978       /* ANSI C++ June 5 1992 WP 11.4.5.  A friend function defined in a
12979          class is in the (lexical) scope of the class in which it is
12980          defined.  */
12981       if (!ctype && DECL_FRIEND_P (decl1))
12982         {
12983           ctype = DECL_CLASS_CONTEXT (decl1);
12984
12985           /* CTYPE could be null here if we're dealing with a template;
12986              for example, `inline friend float foo()' inside a template
12987              will have no CTYPE set.  */
12988           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
12989             ctype = NULL_TREE;
12990           else
12991             doing_friend = 1;
12992         }
12993
12994       last_function_parms = DECL_ARGUMENTS (decl1);
12995       last_function_parm_tags = NULL_TREE;
12996     }
12997   else
12998     {
12999       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL_TREE);
13000       /* If the declarator is not suitable for a function definition,
13001          cause a syntax error.  */
13002       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
13003
13004       fntype = TREE_TYPE (decl1);
13005
13006       restype = TREE_TYPE (fntype);
13007       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13008         {
13009           cp_error ("semicolon missing after declaration of `%#T'", restype);
13010           shadow_tag (build_tree_list (NULL_TREE, restype));
13011           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13012           if (TREE_CODE (fntype) == FUNCTION_TYPE)
13013             fntype = build_function_type (integer_type_node,
13014                                           TYPE_ARG_TYPES (fntype));
13015           else
13016             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13017                                               integer_type_node,
13018                                               TYPE_ARG_TYPES (fntype));
13019           TREE_TYPE (decl1) = fntype;
13020         }
13021
13022       if (TREE_CODE (fntype) == METHOD_TYPE)
13023         ctype = TYPE_METHOD_BASETYPE (fntype);
13024       else if (DECL_MAIN_P (decl1))
13025         {
13026           /* If this doesn't return integer_type, complain.  */
13027           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13028             {
13029               if (pedantic || warn_return_type)
13030                 pedwarn ("return type for `main' changed to `int'");
13031               TREE_TYPE (decl1) = fntype = default_function_type;
13032             }
13033         }
13034     }
13035
13036   /* Sometimes we don't notice that a function is a static member, and
13037      build a METHOD_TYPE for it.  Fix that up now.  */
13038   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13039       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13040     {
13041       revert_static_member_fn (&decl1, NULL, NULL);
13042       last_function_parms = TREE_CHAIN (last_function_parms);
13043       ctype = NULL_TREE;
13044     }
13045
13046   /* Warn if function was previously implicitly declared
13047      (but not if we warned then).  */
13048   if (! warn_implicit
13049       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13050     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13051
13052   /* Set up current_class_type, and enter the scope of the class, if
13053      appropriate.  */
13054   if (ctype)
13055     push_nested_class (ctype, 1);
13056   else if (DECL_STATIC_FUNCTION_P (decl1))
13057     push_nested_class (DECL_CONTEXT (decl1), 2);
13058
13059   /* Now that we have entered the scope of the class, we must restore
13060      the bindings for any template parameters surrounding DECL1, if it
13061      is an inline member template.  (Order is important; consider the
13062      case where a template parameter has the same name as a field of
13063      the class.)  It is not until after this point that
13064      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
13065   if (flags & SF_INCLASS_INLINE)
13066     maybe_begin_member_template_processing (decl1);
13067
13068   /* Effective C++ rule 15.  See also c_expand_return.  */
13069   if (warn_ecpp
13070       && DECL_NAME (decl1) == ansi_opname[(int) MODIFY_EXPR]
13071       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13072     cp_warning ("`operator=' should return a reference to `*this'");
13073
13074   /* Make the init_value nonzero so pushdecl knows this is not tentative.
13075      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
13076   if (!DECL_INITIAL (decl1))
13077     DECL_INITIAL (decl1) = error_mark_node;
13078
13079 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
13080   SET_DEFAULT_DECL_ATTRIBUTES (decl1, attrs);
13081 #endif
13082
13083   /* This function exists in static storage.
13084      (This does not mean `static' in the C sense!)  */
13085   TREE_STATIC (decl1) = 1;
13086
13087   /* We must call push_template_decl after current_class_type is set
13088      up.  (If we are processing inline definitions after exiting a
13089      class scope, current_class_type will be NULL_TREE until set above
13090      by push_nested_class.)  */
13091   if (processing_template_decl)
13092     decl1 = push_template_decl (decl1);
13093
13094   /* We are now in the scope of the function being defined.  */
13095   current_function_decl = decl1;
13096
13097   /* Save the parm names or decls from this function's declarator
13098      where store_parm_decls will find them.  */
13099   current_function_parms = last_function_parms;
13100   current_function_parm_tags = last_function_parm_tags;
13101
13102   /* Make sure the parameter and return types are reasonable.  When
13103      you declare a function, these types can be incomplete, but they
13104      must be complete when you define the function.  */
13105   if (! processing_template_decl)
13106     check_function_type (decl1);
13107
13108   /* Build the return declaration for the function.  */
13109   restype = TREE_TYPE (fntype);
13110   if (!processing_template_decl)
13111     {
13112       if (!DECL_RESULT (decl1))
13113         {
13114           DECL_RESULT (decl1)
13115             = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13116           c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype),
13117                                       DECL_RESULT (decl1));
13118         }
13119     }
13120   else
13121     /* Just use `void'.  Nobody will ever look at this anyhow.  */
13122     DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, void_type_node);
13123
13124   /* Initialize RTL machinery.  We cannot do this until
13125      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
13126      even when processing a template; this is how we get
13127      CFUN set up, and our per-function variables initialized.  */
13128   bl = current_binding_level;
13129   init_function_start (decl1, input_filename, lineno);
13130   current_binding_level = bl;
13131   expanding_p = (flags & SF_EXPAND) != 0;
13132
13133   /* Even though we're inside a function body, we still don't want to
13134      call expand_expr to calculate the size of a variable-sized array.
13135      We haven't necessarily assigned RTL to all variables yet, so it's
13136      not safe to try to expand expressions involving them.  */
13137   immediate_size_expand = 0;
13138   cfun->x_dont_save_pending_sizes_p = 1;
13139
13140   /* If we're building a statement-tree, start the tree now.  */
13141   if (processing_template_decl || !expanding_p)
13142     begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13143
13144   /* Let the user know we're compiling this function.  */
13145   if (processing_template_decl || !building_stmt_tree ())
13146     announce_function (decl1);
13147
13148   /* Record the decl so that the function name is defined.
13149      If we already have a decl for this name, and it is a FUNCTION_DECL,
13150      use the old decl.  */
13151   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13152     {
13153       /* A specialization is not used to guide overload resolution.  */
13154       if ((flag_guiding_decls
13155            || !DECL_TEMPLATE_SPECIALIZATION (decl1))
13156           && ! DECL_FUNCTION_MEMBER_P (decl1))
13157         decl1 = pushdecl (decl1);
13158       else
13159         {
13160           /* We need to set the DECL_CONTEXT. */
13161           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13162             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13163           /* And make sure we have enough default args.  */
13164           check_default_args (decl1);
13165         }
13166       DECL_MAIN_VARIANT (decl1) = decl1;
13167       fntype = TREE_TYPE (decl1);
13168     }
13169
13170   /* Reset these in case the call to pushdecl changed them.  */
13171   current_function_decl = decl1;
13172   cfun->decl = decl1;
13173
13174   /* Initialize the per-function data.  */
13175   if (!DECL_PENDING_INLINE_P (decl1) && DECL_SAVED_FUNCTION_DATA (decl1))
13176     {
13177       /* If we already parsed this function, and we're just expanding it
13178          now, restore saved state.  */
13179       struct binding_level *bl = current_binding_level;
13180       *cp_function_chain = *DECL_SAVED_FUNCTION_DATA (decl1);
13181       current_binding_level = bl;
13182
13183       /* This function is being processed in whole-function mode; we
13184          already did semantic analysis.  */
13185       cfun->x_whole_function_mode_p = 1;
13186
13187       /* If we decided that we didn't want to inline this function,
13188          make sure the back-end knows that.  */
13189       if (!current_function_cannot_inline)
13190         current_function_cannot_inline = cp_function_chain->cannot_inline;
13191
13192       /* We don't need the saved data anymore.  */
13193       free (DECL_SAVED_FUNCTION_DATA (decl1));
13194       DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13195     }
13196   else if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13197     {
13198       /* We know that this was set up by `grokclassfn'.  We do not
13199          wait until `store_parm_decls', since evil parse errors may
13200          never get us to that point.  Here we keep the consistency
13201          between `current_class_type' and `current_class_ptr'.  */
13202       tree t = DECL_ARGUMENTS (decl1);
13203
13204       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13205                           162);
13206       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13207                           19990811);
13208
13209       cp_function_chain->x_current_class_ref
13210         = build_indirect_ref (t, NULL_PTR);
13211       cp_function_chain->x_current_class_ptr = t;
13212
13213       /* Constructors and destructors need to know whether they're "in
13214          charge" of initializing virtual base classes.  */
13215       if (DECL_DESTRUCTOR_P (decl1))
13216         current_in_charge_parm = TREE_CHAIN (t);
13217       else if (DECL_CONSTRUCTOR_P (decl1)
13218                && TREE_CHAIN (t)
13219                && DECL_ARTIFICIAL (TREE_CHAIN (t))
13220                && (DECL_NAME (TREE_CHAIN (t))
13221                    == in_charge_identifier))
13222         current_in_charge_parm = TREE_CHAIN (t);
13223     }
13224
13225   if (DECL_INTERFACE_KNOWN (decl1))
13226     {
13227       tree ctx = hack_decl_function_context (decl1);
13228
13229       if (DECL_NOT_REALLY_EXTERN (decl1))
13230         DECL_EXTERNAL (decl1) = 0;
13231
13232       if (ctx != NULL_TREE && DECL_THIS_INLINE (ctx)
13233           && TREE_PUBLIC (ctx))
13234         /* This is a function in a local class in an extern inline
13235            function.  */
13236         comdat_linkage (decl1);
13237     }
13238   /* If this function belongs to an interface, it is public.
13239      If it belongs to someone else's interface, it is also external.
13240      This only affects inlines and template instantiations.  */
13241   else if (interface_unknown == 0
13242            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13243                || flag_alt_external_templates))
13244     {
13245       if (DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1)
13246           || processing_template_decl)
13247         {
13248           DECL_EXTERNAL (decl1)
13249             = (interface_only
13250                || (DECL_THIS_INLINE (decl1) && ! flag_implement_inlines
13251                    && !DECL_VINDEX (decl1)));
13252
13253           /* For WIN32 we also want to put these in linkonce sections.  */
13254           maybe_make_one_only (decl1);
13255         }
13256       else
13257         DECL_EXTERNAL (decl1) = 0;
13258       DECL_NOT_REALLY_EXTERN (decl1) = 0;
13259       DECL_INTERFACE_KNOWN (decl1) = 1;
13260     }
13261   else if (interface_unknown && interface_only
13262            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13263                || flag_alt_external_templates))
13264     {
13265       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13266          interface, we will have interface_only set but not
13267          interface_known.  In that case, we don't want to use the normal
13268          heuristics because someone will supply a #pragma implementation
13269          elsewhere, and deducing it here would produce a conflict.  */
13270       comdat_linkage (decl1);
13271       DECL_EXTERNAL (decl1) = 0;
13272       DECL_INTERFACE_KNOWN (decl1) = 1;
13273       DECL_DEFER_OUTPUT (decl1) = 1;
13274     }
13275   else
13276     {
13277       /* This is a definition, not a reference.
13278          So clear DECL_EXTERNAL.  */
13279       DECL_EXTERNAL (decl1) = 0;
13280
13281       if ((DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1))
13282           && ! DECL_INTERFACE_KNOWN (decl1)
13283           /* Don't try to defer nested functions for now.  */
13284           && ! hack_decl_function_context (decl1))
13285         DECL_DEFER_OUTPUT (decl1) = 1;
13286       else
13287         DECL_INTERFACE_KNOWN (decl1) = 1;
13288     }
13289
13290   if (doing_semantic_analysis_p ())
13291     {
13292       pushlevel (0);
13293       current_binding_level->parm_flag = 1;
13294     }
13295
13296   if (attrs)
13297     cplus_decl_attributes (decl1, NULL_TREE, attrs);
13298
13299   if (!building_stmt_tree ())
13300     {
13301       GNU_xref_function (decl1, current_function_parms);
13302       make_function_rtl (decl1);
13303     }
13304
13305   /* Promote the value to int before returning it.  */
13306   if (C_PROMOTING_INTEGER_TYPE_P (restype))
13307     restype = type_promotes_to (restype);
13308
13309   /* If this fcn was already referenced via a block-scope `extern' decl
13310      (or an implicit decl), propagate certain information about the usage.  */
13311   if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1)))
13312     TREE_ADDRESSABLE (decl1) = 1;
13313
13314   if (DECL_RESULT (decl1) == NULL_TREE)
13315     {
13316       DECL_RESULT (decl1)
13317         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13318       TREE_READONLY (DECL_RESULT (decl1)) = CP_TYPE_CONST_P (restype);
13319       TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = CP_TYPE_VOLATILE_P (restype);
13320     }
13321
13322   ++function_depth;
13323
13324   if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl1))
13325       && DECL_LANGUAGE (decl1) == lang_cplusplus)
13326     {
13327       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13328       DECL_CONTEXT (dtor_label) = current_function_decl;
13329     }
13330   else if (DECL_CONSTRUCTOR_P (decl1))
13331     {
13332       ctor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13333       DECL_CONTEXT (ctor_label) = current_function_decl;
13334     }
13335
13336   return 1;
13337 }
13338 \f
13339 /* Called after store_parm_decls for a function-try-block.  */
13340
13341 void
13342 expand_start_early_try_stmts ()
13343 {
13344   expand_start_try_stmts ();
13345 }
13346
13347 /* Store the parameter declarations into the current function declaration.
13348    This is called after parsing the parameter declarations, before
13349    digesting the body of the function.
13350
13351    Also install to binding contour return value identifier, if any.  */
13352
13353 void
13354 store_parm_decls ()
13355 {
13356   register tree fndecl = current_function_decl;
13357   register tree parm;
13358   int parms_have_cleanups = 0;
13359   tree cleanups = NULL_TREE;
13360
13361   /* This is a list of types declared among parms in a prototype.  */
13362   tree parmtags = current_function_parm_tags;
13363
13364   /* This is a chain of any other decls that came in among the parm
13365      declarations.  If a parm is declared with  enum {foo, bar} x;
13366      then CONST_DECLs for foo and bar are put here.  */
13367   tree nonparms = NULL_TREE;
13368
13369   /* Create a binding level for the parms.  */
13370   if (!building_stmt_tree ())
13371     expand_start_bindings (2);
13372
13373   if (current_function_parms)
13374     {
13375       /* This case is when the function was defined with an ANSI prototype.
13376          The parms already have decls, so we need not do anything here
13377          except record them as in effect
13378          and complain if any redundant old-style parm decls were written.  */
13379
13380       tree specparms = current_function_parms;
13381       tree next;
13382
13383       if (doing_semantic_analysis_p ())
13384         {
13385           /* Must clear this because it might contain TYPE_DECLs declared
13386              at class level.  */
13387           storedecls (NULL_TREE);
13388
13389           /* If we're doing semantic analysis, then we'll call pushdecl
13390              for each of these.  We must do them in reverse order so that
13391              they end in the correct forward order.  */
13392           specparms = nreverse (specparms);
13393         }
13394
13395       for (parm = specparms; parm; parm = next)
13396         {
13397           next = TREE_CHAIN (parm);
13398           if (TREE_CODE (parm) == PARM_DECL)
13399             {
13400               tree type = TREE_TYPE (parm);
13401
13402               if (doing_semantic_analysis_p ())
13403                 {
13404                   tree cleanup;
13405
13406                   if (DECL_NAME (parm) == NULL_TREE
13407                       || TREE_CODE (parm) != VOID_TYPE)
13408                     pushdecl (parm);
13409                   else
13410                     cp_error ("parameter `%D' declared void", parm);
13411
13412                   cleanup = maybe_build_cleanup (parm);
13413
13414                   if (cleanup)
13415                     cleanups = tree_cons (parm, cleanup, cleanups);
13416                 }
13417               else if (type != error_mark_node
13418                        && TYPE_NEEDS_DESTRUCTOR (type))
13419                 parms_have_cleanups = 1;
13420             }
13421           else
13422             {
13423               /* If we find an enum constant or a type tag,
13424                  put it aside for the moment.  */
13425               TREE_CHAIN (parm) = NULL_TREE;
13426               nonparms = chainon (nonparms, parm);
13427             }
13428         }
13429
13430       if (doing_semantic_analysis_p ())
13431         {
13432           /* Get the decls in their original chain order
13433              and record in the function.  This is all and only the
13434              PARM_DECLs that were pushed into scope by the loop above.  */
13435           DECL_ARGUMENTS (fndecl) = getdecls ();
13436           storetags (chainon (parmtags, gettags ()));
13437         }
13438     }
13439   else
13440     DECL_ARGUMENTS (fndecl) = NULL_TREE;
13441
13442   /* Now store the final chain of decls for the arguments
13443      as the decl-chain of the current lexical scope.
13444      Put the enumerators in as well, at the front so that
13445      DECL_ARGUMENTS is not modified.  */
13446   if (doing_semantic_analysis_p ())
13447     storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
13448
13449   /* Initialize the RTL code for the function.  */
13450   DECL_SAVED_INSNS (fndecl) = 0;
13451   if (! building_stmt_tree ())
13452     expand_function_start (fndecl, parms_have_cleanups);
13453
13454   current_function_parms_stored = 1;
13455
13456   /* If this function is `main', emit a call to `__main'
13457      to run global initializers, etc.  */
13458   if (DECL_MAIN_P (fndecl) && !building_stmt_tree ())
13459     expand_main_function ();
13460
13461   /* Now that we have initialized the parms, we can start their
13462      cleanups.  We cannot do this before, since expand_decl_cleanup
13463      should not be called before the parm can be used.  */
13464   while (cleanups)
13465     {
13466       finish_decl_cleanup (TREE_PURPOSE (cleanups),
13467                            TREE_VALUE (cleanups));
13468       cleanups = TREE_CHAIN (cleanups);
13469     }
13470
13471   /* Create a binding contour which can be used to catch
13472      cleanup-generated temporaries.  Also, if the return value needs or
13473      has initialization, deal with that now.  */
13474   if (parms_have_cleanups)
13475     {
13476       pushlevel (0);
13477       if (!building_stmt_tree ())
13478         expand_start_bindings (2);
13479     }
13480
13481   /* Do the starting of the exception specifications, if we have any.  */
13482   if (flag_exceptions && !processing_template_decl
13483       && building_stmt_tree ()
13484       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13485     current_eh_spec_try_block = expand_start_eh_spec ();
13486 }
13487
13488 /* Bind a name and initialization to the return value of
13489    the current function.  */
13490
13491 void
13492 store_return_init (decl)
13493      tree decl;
13494 {
13495   /* If this named return value comes in a register, put it in a
13496      pseudo-register.  */
13497   if (DECL_REGISTER (decl))
13498     {
13499       original_result_rtx = DECL_RTL (decl);
13500       /* Note that the mode of the old DECL_RTL may be wider than the
13501          mode of DECL_RESULT, depending on the calling conventions for
13502          the processor.  For example, on the Alpha, a 32-bit integer
13503          is returned in a DImode register -- the DECL_RESULT has
13504          SImode but the DECL_RTL for the DECL_RESULT has DImode.  So,
13505          here, we use the mode the back-end has already assigned for
13506          the return value.  */
13507       DECL_RTL (decl) = gen_reg_rtx (GET_MODE (original_result_rtx));
13508     }
13509 }
13510
13511 \f
13512 /* We have finished doing semantic analysis on DECL, but have not yet
13513    generated RTL for its body.  Save away our current state, so that
13514    when we want to generate RTL later we know what to do.  */
13515
13516 static void
13517 save_function_data (decl)
13518      tree decl;
13519 {
13520   struct language_function *f;
13521
13522   /* Save the language-specific per-function data so that we can
13523      get it back when we really expand this function.  */
13524   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
13525                       19990908);
13526
13527   /* Make a copy.  */
13528   f = ((struct language_function *)
13529        xmalloc (sizeof (struct language_function)));
13530   bcopy ((char *) cp_function_chain, (char *) f,
13531          sizeof (struct language_function));
13532   DECL_SAVED_FUNCTION_DATA (decl) = f;
13533
13534   /* Clear out the bits we don't need.  */
13535   f->x_base_init_list = NULL_TREE;
13536   f->x_member_init_list = NULL_TREE;
13537   f->x_stmt_tree.x_last_stmt = NULL_TREE;
13538   f->x_stmt_tree.x_last_expr_type = NULL_TREE;
13539   f->x_result_rtx = NULL_RTX;
13540   f->x_named_label_uses = NULL;
13541   f->bindings = NULL;
13542
13543   /* When we get back here again, we will be expanding.  */
13544   f->x_expanding_p = 1;
13545
13546   /* If we've already decided that we cannot inline this function, we
13547      must remember that fact when we actually go to expand the
13548      function.  */
13549   f->cannot_inline = current_function_cannot_inline;
13550 }
13551
13552 /* At the end of every constructor we generate to code to return
13553    `this'.  Do that now.  */
13554
13555 static void
13556 finish_constructor_body ()
13557 {
13558   /* Any return from a constructor will end up here.  */
13559   add_tree (build_min_nt (LABEL_STMT, ctor_label));
13560
13561   /* Clear CTOR_LABEL so that finish_return_stmt knows to really
13562      generate the return, rather than a goto to CTOR_LABEL.  */
13563   ctor_label = NULL_TREE;
13564   /* In check_return_expr we translate an empty return from a
13565      constructor to a return of `this'.  */
13566   finish_return_stmt (NULL_TREE);
13567   /* Mark the end of the constructor.  */
13568   add_tree (build_min_nt (CTOR_STMT));
13569 }
13570
13571 /* At the end of every destructor we generate code to restore virtual
13572    function tables to the values desired by base classes and to call
13573    to base class destructors.  Do that now.  */
13574
13575 static void
13576 finish_destructor_body ()
13577 {
13578   tree compound_stmt;
13579   tree in_charge;
13580   tree virtual_size;
13581   tree exprstmt;
13582
13583   /* Create a block to contain all the extra code.  */
13584   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
13585
13586   /* Any return from a destructor will end up here.  */
13587   add_tree (build_min_nt (LABEL_STMT, dtor_label));
13588
13589   /* Generate the code to call destructor on base class.  If this
13590      destructor belongs to a class with virtual functions, then set
13591      the virtual function table pointer to represent the type of our
13592      base class.  */
13593
13594   /* This side-effect makes call to `build_delete' generate the code
13595      we have to have at the end of this destructor.  `build_delete'
13596      will set the flag again.  */
13597   TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
13598
13599   /* These are two cases where we cannot delegate deletion.  */
13600   if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)
13601       || TYPE_GETS_REG_DELETE (current_class_type))
13602     in_charge = integer_zero_node;
13603   else
13604     in_charge = current_in_charge_parm;
13605
13606   exprstmt = build_delete (current_class_type,
13607                            current_class_ref,
13608                            in_charge,
13609                            LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
13610                            0);
13611
13612   if (exprstmt != error_mark_node
13613       && (TREE_CODE (exprstmt) != NOP_EXPR
13614           || TREE_OPERAND (exprstmt, 0) != integer_zero_node
13615           || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
13616     {
13617       if (exprstmt != void_zero_node)
13618         /* Don't call `expand_expr_stmt' if we're not going to do
13619            anything, since -Wall will give a diagnostic.  */
13620         finish_expr_stmt (exprstmt);
13621
13622       /* Run destructors for all virtual baseclasses.  */
13623       if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
13624         {
13625           tree vbases = nreverse (copy_list (CLASSTYPE_VBASECLASSES (current_class_type)));
13626           tree if_stmt = begin_if_stmt ();
13627           finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
13628                                       current_in_charge_parm,
13629                                       integer_two_node),
13630                                if_stmt);
13631
13632           while (vbases)
13633             {
13634               if (TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (vbases)))
13635                 {
13636                   tree vb = get_vbase
13637                     (BINFO_TYPE (vbases),
13638                      TYPE_BINFO (current_class_type));
13639                   finish_expr_stmt
13640                     (build_scoped_method_call
13641                      (current_class_ref, vb, dtor_identifier,
13642                       build_tree_list (NULL_TREE, integer_zero_node)));
13643                 }
13644               vbases = TREE_CHAIN (vbases);
13645             }
13646
13647           finish_then_clause (if_stmt);
13648           finish_if_stmt ();
13649         }
13650     }
13651
13652   virtual_size = c_sizeof (current_class_type);
13653
13654   /* At the end, call delete if that's what's requested.  */
13655
13656   /* FDIS sez: At the point of definition of a virtual destructor
13657      (including an implicit definition), non-placement operator delete
13658      shall be looked up in the scope of the destructor's class and if
13659      found shall be accessible and unambiguous.
13660
13661      This is somewhat unclear, but I take it to mean that if the class
13662      only defines placement deletes we don't do anything here.  So we
13663      pass LOOKUP_SPECULATIVELY; delete_sanity will complain for us if
13664      they ever try to delete one of these.  */
13665   if (TYPE_GETS_REG_DELETE (current_class_type)
13666       || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
13667     {
13668       tree if_stmt;
13669
13670       exprstmt = build_op_delete_call
13671         (DELETE_EXPR, current_class_ptr, virtual_size,
13672          LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
13673
13674       if_stmt = begin_if_stmt ();
13675       finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
13676                                   current_in_charge_parm,
13677                                   integer_one_node),
13678                            if_stmt);
13679       finish_expr_stmt (exprstmt);
13680       finish_then_clause (if_stmt);
13681       finish_if_stmt ();
13682     }
13683
13684   /* Close the block we started above.  */
13685   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
13686 }
13687
13688 /* Finish up a function declaration and compile that function
13689    all the way to assembler language output.  The free the storage
13690    for the function definition.
13691
13692    This is called after parsing the body of the function definition.
13693    LINENO is the current line number.
13694
13695    FLAGS is a bitwise or of the following values:
13696      1 - CALL_POPLEVEL
13697        An extra call to poplevel (and expand_end_bindings) must be
13698        made to take care of the binding contour for the base
13699        initializers.  This is only relevant for constructors.
13700      2 - INCLASS_INLINE
13701        We just finished processing the body of an in-class inline
13702        function definition.  (This processing will have taken place
13703        after the class definition is complete.)  */
13704
13705 tree
13706 finish_function (lineno, flags)
13707      int lineno;
13708      int flags;
13709 {
13710   register tree fndecl = current_function_decl;
13711   tree fntype, ctype = NULL_TREE;
13712   /* Label to use if this function is supposed to return a value.  */
13713   tree no_return_label = NULL_TREE;
13714   int call_poplevel = (flags & 1) != 0;
13715   int inclass_inline = (flags & 2) != 0;
13716   int expand_p;
13717   int nested;
13718
13719   /* When we get some parse errors, we can end up without a
13720      current_function_decl, so cope.  */
13721   if (fndecl == NULL_TREE)
13722     return error_mark_node;
13723
13724   nested = function_depth > 1;
13725   fntype = TREE_TYPE (fndecl);
13726
13727   /*  TREE_READONLY (fndecl) = 1;
13728       This caused &foo to be of type ptr-to-const-function
13729       which then got a warning when stored in a ptr-to-function variable.  */
13730
13731   /* This happens on strange parse errors.  */
13732   if (! current_function_parms_stored)
13733     {
13734       call_poplevel = 0;
13735       store_parm_decls ();
13736     }
13737
13738   if (building_stmt_tree ())
13739     {
13740       if (DECL_CONSTRUCTOR_P (fndecl))
13741         {
13742           finish_constructor_body ();
13743           if (call_poplevel)
13744             do_poplevel ();
13745         }
13746       else if (DECL_DESTRUCTOR_P (fndecl) && !processing_template_decl)
13747         finish_destructor_body ();
13748       else if (DECL_MAIN_P (fndecl))
13749         {
13750           /* Make it so that `main' always returns 0 by default.  */
13751 #ifdef VMS
13752           finish_return_stmt (integer_one_node);
13753 #else
13754           finish_return_stmt (integer_zero_node);
13755 #endif
13756         }
13757
13758       /* Finish dealing with exception specifiers.  */
13759       if (flag_exceptions && !processing_template_decl
13760           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13761         expand_end_eh_spec (TYPE_RAISES_EXCEPTIONS
13762                             (TREE_TYPE (current_function_decl)),
13763                             current_eh_spec_try_block);
13764     }
13765   else
13766     {
13767 #if 0
13768       if (write_symbols != NO_DEBUG /*&& TREE_CODE (fntype) != METHOD_TYPE*/)
13769         {
13770           /* Keep this code around in case we later want to control debug info
13771              based on whether a type is "used".  (jason 1999-11-11) */
13772
13773           tree ttype = target_type (fntype);
13774           tree parmdecl;
13775
13776           if (IS_AGGR_TYPE (ttype))
13777             /* Let debugger know it should output info for this type.  */
13778             note_debug_info_needed (ttype);
13779
13780           for (parmdecl = DECL_ARGUMENTS (fndecl); parmdecl; parmdecl = TREE_CHAIN (parmdecl))
13781             {
13782               ttype = target_type (TREE_TYPE (parmdecl));
13783               if (IS_AGGR_TYPE (ttype))
13784                 /* Let debugger know it should output info for this type.  */
13785                 note_debug_info_needed (ttype);
13786             }
13787         }
13788 #endif
13789
13790       /* Clean house because we will need to reorder insns here.  */
13791       do_pending_stack_adjust ();
13792
13793       if (dtor_label)
13794         ;
13795       else if (DECL_CONSTRUCTOR_P (fndecl))
13796         {
13797           if (call_poplevel)
13798             do_poplevel ();
13799         }
13800       else if (return_label != NULL_RTX
13801                && flag_this_is_variable <= 0
13802                && current_function_return_value == NULL_TREE
13803                && ! DECL_NAME (DECL_RESULT (current_function_decl)))
13804         no_return_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13805
13806       if (flag_exceptions)
13807         expand_exception_blocks ();
13808
13809       /* If this function is supposed to return a value, ensure that
13810          we do not fall into the cleanups by mistake.  The end of our
13811          function will look like this:
13812
13813          user code (may have return stmt somewhere)
13814          goto no_return_label
13815          cleanup_label:
13816          cleanups
13817          goto return_label
13818          no_return_label:
13819          NOTE_INSN_FUNCTION_END
13820          return_label:
13821          things for return
13822
13823          If the user omits a return stmt in the USER CODE section, we
13824          will have a control path which reaches NOTE_INSN_FUNCTION_END.
13825          Otherwise, we won't.  */
13826       if (no_return_label)
13827         {
13828           DECL_CONTEXT (no_return_label) = fndecl;
13829           DECL_INITIAL (no_return_label) = error_mark_node;
13830           DECL_SOURCE_FILE (no_return_label) = input_filename;
13831           DECL_SOURCE_LINE (no_return_label) = lineno;
13832           expand_goto (no_return_label);
13833         }
13834
13835       if (cleanup_label)
13836         {
13837           /* Remove the binding contour which is used
13838              to catch cleanup-generated temporaries.  */
13839           expand_end_bindings (0, 0, 0);
13840           poplevel (0, 0, 0);
13841
13842           /* Emit label at beginning of cleanup code for parameters.  */
13843           emit_label (cleanup_label);
13844         }
13845
13846       /* Get return value into register if that's where it's supposed
13847          to be.  */
13848       if (original_result_rtx)
13849         fixup_result_decl (DECL_RESULT (fndecl), original_result_rtx);
13850
13851       /* Finish building code that will trigger warnings if users forget
13852          to make their functions return values.  */
13853       if (no_return_label || cleanup_label)
13854         emit_jump (return_label);
13855       if (no_return_label)
13856         {
13857           /* We don't need to call `expand_*_return' here because we
13858              don't need any cleanups here--this path of code is only
13859              for error checking purposes.  */
13860           expand_label (no_return_label);
13861         }
13862
13863       /* We hard-wired immediate_size_expand to zero in
13864          start_function.  Expand_function_end will decrement this
13865          variable.  So, we set the variable to one here, so that after
13866          the decrement it will remain zero.  */
13867       immediate_size_expand = 1;
13868
13869       /* Generate rtl for function exit.  */
13870       expand_function_end (input_filename, lineno, 1);
13871     }
13872
13873   /* We have to save this value here in case
13874      maybe_end_member_template_processing decides to pop all the
13875      template parameters.  */
13876   expand_p = !building_stmt_tree ();
13877
13878   /* If we're saving up tree structure, tie off the function now.  */
13879   if (!expand_p)
13880     finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
13881
13882   /* This must come after expand_function_end because cleanups might
13883      have declarations (from inline functions) that need to go into
13884      this function's blocks.  */
13885   if (doing_semantic_analysis_p ())
13886     {
13887       if (current_binding_level->parm_flag != 1)
13888         my_friendly_abort (122);
13889       poplevel (1, 0, 1);
13890     }
13891
13892   /* Remember that we were in class scope.  */
13893   if (current_class_name)
13894     ctype = current_class_type;
13895
13896   /* Must mark the RESULT_DECL as being in this function.  */
13897   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
13898
13899   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
13900      to the FUNCTION_DECL node itself.  */
13901   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
13902
13903   /* Save away current state, if appropriate.  */
13904   if (!expanding_p && !processing_template_decl)
13905     save_function_data (fndecl);
13906
13907   /* If this function calls `setjmp' it cannot be inlined.  When
13908      `longjmp' is called it is not guaranteed to restore the value of
13909      local variables that have been modified since the call to
13910      `setjmp'.  So, if were to inline this function into some caller
13911      `c', then when we `longjmp', we might not restore all variables
13912      in `c'.  (It might seem, at first blush, that there's no way for
13913      this function to modify local variables in `c', but their
13914      addresses may have been stored somewhere accessible to this
13915      function.)  */
13916   if (!expanding_p && !processing_template_decl && calls_setjmp_p (fndecl))
13917     DECL_UNINLINABLE (fndecl) = 1;
13918
13919   if (expand_p)
13920     {
13921       int returns_null;
13922       int returns_value;
13923       int saved_flag_keep_inline_functions =
13924         flag_keep_inline_functions;
13925
13926       /* So we can tell if jump_optimize sets it to 1.  */
13927       can_reach_end = 0;
13928
13929       if (DECL_CONTEXT (fndecl) != NULL_TREE
13930           && hack_decl_function_context (fndecl))
13931         /* Trick rest_of_compilation into not deferring output of this
13932            function, even if it is inline, since the rtl_obstack for
13933            this function is the function_obstack of the enclosing
13934            function and will be deallocated when the enclosing
13935            function is gone.  See save_tree_status.  */
13936         flag_keep_inline_functions = 1;
13937
13938       /* Before we call rest_of_compilation (which will pop the
13939          CURRENT_FUNCTION), we must save these values.  */
13940       returns_null = current_function_returns_null;
13941       returns_value = current_function_returns_value;
13942
13943       /* If this is a nested function (like a template instantiation
13944          that we're compiling in the midst of compiling something
13945          else), push a new GC context.  That will keep local variables
13946          on the stack from being collected while we're doing the
13947          compilation of this function.  */
13948       if (function_depth > 1)
13949         ggc_push_context ();
13950
13951       /* Run the optimizers and output the assembler code for this
13952          function.  */
13953       if (DECL_ARTIFICIAL (fndecl))
13954         {
13955           /* Do we really *want* to inline this synthesized method?  */
13956
13957           int save_fif = flag_inline_functions;
13958           flag_inline_functions = 1;
13959
13960           /* Turn off DECL_INLINE for the moment so function_cannot_inline_p
13961              will check our size.  */
13962           DECL_INLINE (fndecl) = 0;
13963
13964           rest_of_compilation (fndecl);
13965           flag_inline_functions = save_fif;
13966         }
13967       else
13968         rest_of_compilation (fndecl);
13969
13970       /* Undo the call to ggc_push_context above.  */
13971       if (function_depth > 1)
13972         ggc_pop_context ();
13973
13974       flag_keep_inline_functions = saved_flag_keep_inline_functions;
13975
13976       if (DECL_SAVED_INSNS (fndecl) && ! TREE_ASM_WRITTEN (fndecl))
13977         {
13978           /* Set DECL_EXTERNAL so that assemble_external will be called as
13979              necessary.  We'll clear it again in finish_file.  */
13980           if (! DECL_EXTERNAL (fndecl))
13981             DECL_NOT_REALLY_EXTERN (fndecl) = 1;
13982           DECL_EXTERNAL (fndecl) = 1;
13983           mark_inline_for_output (fndecl);
13984         }
13985
13986 #if 0
13987       /* Keep this code around in case we later want to control debug info
13988          based on whether a type is "used".  (jason 1999-11-11) */
13989
13990       if (ctype && TREE_ASM_WRITTEN (fndecl))
13991         note_debug_info_needed (ctype);
13992 #endif
13993
13994       returns_null |= can_reach_end;
13995
13996       /* Since we don't normally go through c_expand_return for constructors,
13997          this normally gets the wrong value.
13998          Also, named return values have their return codes emitted after
13999          NOTE_INSN_FUNCTION_END, confusing jump.c.  */
14000       if (DECL_CONSTRUCTOR_P (fndecl)
14001           || DECL_NAME (DECL_RESULT (fndecl)) != NULL_TREE)
14002         returns_null = 0;
14003
14004       if (TREE_THIS_VOLATILE (fndecl) && returns_null)
14005         cp_warning ("`noreturn' function `%D' does return", fndecl);
14006       else if ((warn_return_type || pedantic)
14007                && returns_null
14008                && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE)
14009         {
14010           /* If this function returns non-void and control can drop through,
14011              complain.  */
14012           cp_warning ("control reaches end of non-void function `%D'", fndecl);
14013         }
14014       /* With just -W, complain only if function returns both with
14015          and without a value.  */
14016       else if (extra_warnings && returns_value && returns_null)
14017         warning ("this function may return with or without a value");
14018     }
14019   else
14020     {
14021       /* Clear out memory we no longer need.  */
14022       free_after_parsing (cfun);
14023       /* Since we never call rest_of_compilation, we never clear
14024          CFUN.  Do so explicitly.  */
14025       free_after_compilation (cfun);
14026       cfun = NULL;
14027     }
14028
14029   /* If this is a in-class inline definition, we may have to pop the
14030      bindings for the template parameters that we added in
14031      maybe_begin_member_template_processing when start_function was
14032      called.  */
14033   if (inclass_inline)
14034     maybe_end_member_template_processing ();
14035
14036   /* Leave the scope of the class.  */
14037   if (ctype)
14038     pop_nested_class ();
14039
14040   --function_depth;
14041
14042   if (!DECL_SAVED_INSNS (fndecl) && !DECL_SAVED_FUNCTION_DATA (fndecl)
14043       && !(flag_inline_trees && DECL_INLINE (fndecl)))
14044     {
14045       tree t;
14046
14047       /* Stop pointing to the local nodes about to be freed.  */
14048       /* But DECL_INITIAL must remain nonzero so we know this
14049          was an actual function definition.  */
14050       DECL_INITIAL (fndecl) = error_mark_node;
14051       for (t = DECL_ARGUMENTS (fndecl); t; t = TREE_CHAIN (t))
14052         DECL_RTL (t) = DECL_INCOMING_RTL (t) = NULL_RTX;
14053     }
14054
14055   if (DECL_STATIC_CONSTRUCTOR (fndecl))
14056     static_ctors = tree_cons (NULL_TREE, fndecl, static_ctors);
14057   if (DECL_STATIC_DESTRUCTOR (fndecl))
14058     static_dtors = tree_cons (NULL_TREE, fndecl, static_dtors);
14059
14060   /* Clean up.  */
14061   if (! nested)
14062     {
14063       /* Let the error reporting routines know that we're outside a
14064          function.  For a nested function, this value is used in
14065          pop_cp_function_context and then reset via pop_function_context.  */
14066       current_function_decl = NULL_TREE;
14067       /* We don't really care about obstacks, but the middle-end
14068          sometimes cares on what obstck things are located.  */
14069       permanent_allocation (1);
14070     }
14071
14072   return fndecl;
14073 }
14074 \f
14075 /* Create the FUNCTION_DECL for a function definition.
14076    DECLSPECS and DECLARATOR are the parts of the declaration;
14077    they describe the return type and the name of the function,
14078    but twisted together in a fashion that parallels the syntax of C.
14079
14080    This function creates a binding context for the function body
14081    as well as setting up the FUNCTION_DECL in current_function_decl.
14082
14083    Returns a FUNCTION_DECL on success.
14084
14085    If the DECLARATOR is not suitable for a function (it defines a datum
14086    instead), we return 0, which tells yyparse to report a parse error.
14087
14088    May return void_type_node indicating that this method is actually
14089    a friend.  See grokfield for more details.
14090
14091    Came here with a `.pushlevel' .
14092
14093    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14094    CHANGES TO CODE IN `grokfield'.  */
14095
14096 tree
14097 start_method (declspecs, declarator, attrlist)
14098      tree declarator, declspecs, attrlist;
14099 {
14100   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14101                                 attrlist);
14102
14103   /* Something too ugly to handle.  */
14104   if (fndecl == NULL_TREE)
14105     return NULL_TREE;
14106
14107   /* Pass friends other than inline friend functions back.  */
14108   if (fndecl == void_type_node)
14109     return fndecl;
14110
14111   if (TREE_CODE (fndecl) != FUNCTION_DECL)
14112     /* Not a function, tell parser to report parse error.  */
14113     return NULL_TREE;
14114
14115   if (DECL_IN_AGGR_P (fndecl))
14116     {
14117       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14118         {
14119           if (DECL_CONTEXT (fndecl)
14120               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14121             cp_error ("`%D' is already defined in class %s", fndecl,
14122                              TYPE_NAME_STRING (DECL_CONTEXT (fndecl)));
14123         }
14124       return void_type_node;
14125     }
14126
14127   check_template_shadow (fndecl);
14128
14129   DECL_THIS_INLINE (fndecl) = 1;
14130
14131   if (flag_default_inline)
14132     DECL_INLINE (fndecl) = 1;
14133
14134   /* We process method specializations in finish_struct_1.  */
14135   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14136     fndecl = push_template_decl (fndecl);
14137
14138   /* We read in the parameters on the maybepermanent_obstack,
14139      but we won't be getting back to them until after we
14140      may have clobbered them.  So the call to preserve_data
14141      will keep them safe.  */
14142   preserve_data ();
14143
14144   if (! DECL_FRIEND_P (fndecl))
14145     {
14146       if (TREE_CHAIN (fndecl))
14147         {
14148           fndecl = copy_node (fndecl);
14149           TREE_CHAIN (fndecl) = NULL_TREE;
14150         }
14151
14152       if (DECL_CONSTRUCTOR_P (fndecl))
14153         {
14154           if (! grok_ctor_properties (current_class_type, fndecl))
14155             return void_type_node;
14156         }
14157       else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl)))
14158         grok_op_properties (fndecl, DECL_VIRTUAL_P (fndecl), 0);
14159     }
14160
14161   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14162
14163   /* Make a place for the parms */
14164   pushlevel (0);
14165   current_binding_level->parm_flag = 1;
14166
14167   DECL_IN_AGGR_P (fndecl) = 1;
14168   return fndecl;
14169 }
14170
14171 /* Go through the motions of finishing a function definition.
14172    We don't compile this method until after the whole class has
14173    been processed.
14174
14175    FINISH_METHOD must return something that looks as though it
14176    came from GROKFIELD (since we are defining a method, after all).
14177
14178    This is called after parsing the body of the function definition.
14179    STMTS is the chain of statements that makes up the function body.
14180
14181    DECL is the ..._DECL that `start_method' provided.  */
14182
14183 tree
14184 finish_method (decl)
14185      tree decl;
14186 {
14187   register tree fndecl = decl;
14188   tree old_initial;
14189
14190   register tree link;
14191
14192   if (decl == void_type_node)
14193     return decl;
14194
14195   old_initial = DECL_INITIAL (fndecl);
14196
14197   /* Undo the level for the parms (from start_method).
14198      This is like poplevel, but it causes nothing to be
14199      saved.  Saving information here confuses symbol-table
14200      output routines.  Besides, this information will
14201      be correctly output when this method is actually
14202      compiled.  */
14203
14204   /* Clear out the meanings of the local variables of this level;
14205      also record in each decl which block it belongs to.  */
14206
14207   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14208     {
14209       if (DECL_NAME (link) != NULL_TREE)
14210         pop_binding (DECL_NAME (link), link);
14211       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14212       DECL_CONTEXT (link) = NULL_TREE;
14213     }
14214
14215   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
14216                       (HOST_WIDE_INT) current_binding_level->level_chain,
14217                       current_binding_level->parm_flag,
14218                       current_binding_level->keep);
14219
14220   poplevel (0, 0, 0);
14221
14222   DECL_INITIAL (fndecl) = old_initial;
14223
14224   /* We used to check if the context of FNDECL was different from
14225      current_class_type as another way to get inside here.  This didn't work
14226      for String.cc in libg++.  */
14227   if (DECL_FRIEND_P (fndecl))
14228     {
14229       CLASSTYPE_INLINE_FRIENDS (current_class_type)
14230         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14231       decl = void_type_node;
14232     }
14233
14234   return decl;
14235 }
14236 \f
14237 /* Called when a new struct TYPE is defined.
14238    If this structure or union completes the type of any previous
14239    variable declaration, lay it out and output its rtl.  */
14240
14241 void
14242 hack_incomplete_structures (type)
14243      tree type;
14244 {
14245   tree *list;
14246   struct binding_level *level;
14247
14248   if (!type) /* Don't do this for class templates.  */
14249     return;
14250
14251   if (namespace_bindings_p ())
14252     {
14253       level = 0;
14254       list = &namespace_scope_incomplete;
14255     }
14256   else
14257     {
14258       level = innermost_nonclass_level ();
14259       list = &level->incomplete;
14260     }
14261
14262   while (1)
14263     {
14264       while (*list)
14265         {
14266           tree decl = TREE_VALUE (*list);
14267           if ((decl && TREE_TYPE (decl) == type)
14268               || (TREE_TYPE (decl)
14269                   && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14270                   && TREE_TYPE (TREE_TYPE (decl)) == type))
14271             {
14272               int toplevel = toplevel_bindings_p ();
14273               if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14274                   && TREE_TYPE (TREE_TYPE (decl)) == type)
14275                 layout_type (TREE_TYPE (decl));
14276               layout_decl (decl, 0);
14277               rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
14278               if (! toplevel)
14279                 {
14280                   tree cleanup;
14281                   expand_decl (decl);
14282                   cleanup = maybe_build_cleanup (decl);
14283                   expand_decl_init (decl);
14284                   if (! expand_decl_cleanup (decl, cleanup))
14285                     cp_error ("parser lost in parsing declaration of `%D'",
14286                               decl);
14287                 }
14288               *list = TREE_CHAIN (*list);
14289             }
14290           else
14291             list = &TREE_CHAIN (*list);
14292         }
14293
14294       /* Keep looking through artificial binding levels generated
14295          for local variables.  */
14296       if (level && level->keep == 2)
14297         {
14298           level = level->level_chain;
14299           list = &level->incomplete;
14300         }
14301       else
14302         break;
14303     }
14304 }
14305
14306 /* If DECL is of a type which needs a cleanup, build that cleanup here.
14307    See build_delete for information about AUTO_DELETE.
14308
14309    Don't build these on the momentary obstack; they must live
14310    the life of the binding contour.  */
14311
14312 static tree
14313 maybe_build_cleanup_1 (decl, auto_delete)
14314      tree decl, auto_delete;
14315 {
14316   tree type = TREE_TYPE (decl);
14317   if (type != error_mark_node && TYPE_NEEDS_DESTRUCTOR (type))
14318     {
14319       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14320       tree rval;
14321
14322       if (TREE_CODE (type) == ARRAY_TYPE)
14323         rval = decl;
14324       else
14325         {
14326           mark_addressable (decl);
14327           rval = build_unary_op (ADDR_EXPR, decl, 0);
14328         }
14329
14330       /* Optimize for space over speed here.  */
14331       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14332           || flag_expensive_optimizations)
14333         flags |= LOOKUP_NONVIRTUAL;
14334
14335       rval = build_delete (TREE_TYPE (rval), rval, auto_delete, flags, 0);
14336
14337       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14338           && ! TYPE_HAS_DESTRUCTOR (type))
14339         rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14340                                                build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14341
14342       return rval;
14343     }
14344   return 0;
14345 }
14346
14347 /* If DECL is of a type which needs a cleanup, build that cleanup
14348    here.  The cleanup does free the storage with a call to delete.  */
14349
14350 tree
14351 maybe_build_cleanup_and_delete (decl)
14352      tree decl;
14353 {
14354   return maybe_build_cleanup_1 (decl, integer_three_node);
14355 }
14356
14357 /* If DECL is of a type which needs a cleanup, build that cleanup
14358    here.  The cleanup does not free the storage with a call a delete.  */
14359
14360 tree
14361 maybe_build_cleanup (decl)
14362      tree decl;
14363 {
14364   return maybe_build_cleanup_1 (decl, integer_two_node);
14365 }
14366 \f
14367 /* Expand a C++ expression at the statement level.
14368    This is needed to ferret out nodes which have UNKNOWN_TYPE.
14369    The C++ type checker should get all of these out when
14370    expressions are combined with other, type-providing, expressions,
14371    leaving only orphan expressions, such as:
14372
14373    &class::bar;         / / takes its address, but does nothing with it.  */
14374
14375 void
14376 cplus_expand_expr_stmt (exp)
14377      tree exp;
14378 {
14379   if (stmts_are_full_exprs_p)
14380     exp = convert_to_void (exp, "statement");
14381
14382 #if 0
14383   /* We should do this eventually, but right now this causes regex.o from
14384      libg++ to miscompile, and tString to core dump.  */
14385   exp = build1 (CLEANUP_POINT_EXPR, TREE_TYPE (exp), exp);
14386 #endif
14387
14388   /* If we don't do this, we end up down inside expand_expr
14389      trying to do TYPE_MODE on the ERROR_MARK, and really
14390      go outside the bounds of the type.  */
14391   if (exp != error_mark_node)
14392     expand_expr_stmt (exp);
14393 }
14394
14395 /* When a stmt has been parsed, this function is called.  */
14396
14397 void
14398 finish_stmt ()
14399 {
14400   /* Always assume this statement was not an expression statement.  If
14401      it actually was an expression statement, its our callers
14402      responsibility to fix this up.  */
14403   last_expr_type = NULL_TREE;
14404 }
14405
14406 /* Change a static member function definition into a FUNCTION_TYPE, instead
14407    of the METHOD_TYPE that we create when it's originally parsed.
14408
14409    WARNING: DO NOT pass &TREE_TYPE (decl) to FN or &TYPE_ARG_TYPES
14410    (TREE_TYPE (decl)) to ARGTYPES, as doing so will corrupt the types of
14411    other decls.  Either pass the addresses of local variables or NULL.  */
14412
14413 void
14414 revert_static_member_fn (decl, fn, argtypes)
14415      tree *decl, *fn, *argtypes;
14416 {
14417   tree tmp;
14418   tree function = fn ? *fn : TREE_TYPE (*decl);
14419   tree args = argtypes ? *argtypes : TYPE_ARG_TYPES (function);
14420
14421   if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args)))
14422       != TYPE_UNQUALIFIED)
14423     cp_error ("static member function `%#D' declared with type qualifiers",
14424               *decl);
14425
14426   args = TREE_CHAIN (args);
14427   tmp = build_function_type (TREE_TYPE (function), args);
14428   tmp = build_qualified_type (tmp, CP_TYPE_QUALS (function));
14429   tmp = build_exception_variant (tmp,
14430                                  TYPE_RAISES_EXCEPTIONS (function));
14431   TREE_TYPE (*decl) = tmp;
14432   if (DECL_ARGUMENTS (*decl))
14433     DECL_ARGUMENTS (*decl) = TREE_CHAIN (DECL_ARGUMENTS (*decl));
14434   DECL_STATIC_FUNCTION_P (*decl) = 1;
14435   if (fn)
14436     *fn = tmp;
14437   if (argtypes)
14438     *argtypes = args;
14439 }
14440
14441 /* Initialize the variables used during compilation of a C++
14442    function.  */
14443
14444 static void
14445 push_cp_function_context (f)
14446      struct function *f;
14447 {
14448   struct language_function *p
14449     = ((struct language_function *)
14450        xcalloc (1, sizeof (struct language_function)));
14451   f->language = p;
14452
14453   /* It takes an explicit call to expand_body to generate RTL for a
14454      function.  */
14455   expanding_p = 0;
14456
14457   /* Whenever we start a new function, we destroy temporaries in the
14458      usual way.  */
14459   stmts_are_full_exprs_p = 1;
14460 }
14461
14462 /* Free the language-specific parts of F, now that we've finished
14463    compiling the function.  */
14464
14465 static void
14466 pop_cp_function_context (f)
14467      struct function *f;
14468 {
14469   if (f->language)
14470     free (f->language);
14471   f->language = 0;
14472 }
14473
14474 /* Mark P for GC.  */
14475
14476 static void
14477 mark_lang_function (p)
14478      struct language_function *p;
14479 {
14480   if (!p)
14481     return;
14482
14483   ggc_mark_tree (p->x_named_labels);
14484   ggc_mark_tree (p->x_ctor_label);
14485   ggc_mark_tree (p->x_dtor_label);
14486   ggc_mark_tree (p->x_base_init_list);
14487   ggc_mark_tree (p->x_member_init_list);
14488   ggc_mark_tree (p->x_current_class_ptr);
14489   ggc_mark_tree (p->x_current_class_ref);
14490   ggc_mark_tree (p->x_eh_spec_try_block);
14491   ggc_mark_tree (p->x_scope_stmt_stack);
14492
14493   ggc_mark_rtx (p->x_result_rtx);
14494
14495   mark_stmt_tree (&p->x_stmt_tree);
14496   mark_binding_level (&p->bindings);
14497 }
14498
14499 /* Mark the language-specific data in F for GC.  */
14500
14501 static void
14502 mark_cp_function_context (f)
14503      struct function *f;
14504 {
14505   mark_lang_function (f->language);
14506 }
14507
14508 int
14509 in_function_p ()
14510 {
14511   return function_depth != 0;
14512 }
14513
14514
14515 void
14516 lang_mark_false_label_stack (l)
14517      struct label_node *l;
14518 {
14519   /* C++ doesn't use false_label_stack.  It better be NULL.  */
14520   my_friendly_assert (l == NULL, 19990904);
14521 }
14522
14523 void
14524 lang_mark_tree (t)
14525      tree t;
14526 {
14527   enum tree_code code = TREE_CODE (t);
14528   if (code == IDENTIFIER_NODE)
14529     {
14530       struct lang_identifier *li = (struct lang_identifier *) t;
14531       struct lang_id2 *li2 = li->x;
14532       ggc_mark_tree (li->namespace_bindings);
14533       ggc_mark_tree (li->bindings);
14534       ggc_mark_tree (li->class_value);
14535       ggc_mark_tree (li->class_template_info);
14536
14537       if (li2)
14538         {
14539           ggc_mark_tree (li2->label_value);
14540           ggc_mark_tree (li2->implicit_decl);
14541           ggc_mark_tree (li2->error_locus);
14542         }
14543     }
14544   else if (code == CPLUS_BINDING)
14545     {
14546       if (BINDING_HAS_LEVEL_P (t))
14547         mark_binding_level (&BINDING_LEVEL (t));
14548       else
14549         ggc_mark_tree (BINDING_SCOPE (t));
14550       ggc_mark_tree (BINDING_VALUE (t));
14551     }
14552   else if (code == OVERLOAD)
14553     ggc_mark_tree (OVL_FUNCTION (t));
14554   else if (code == TEMPLATE_PARM_INDEX)
14555     ggc_mark_tree (TEMPLATE_PARM_DECL (t));
14556   else if (TREE_CODE_CLASS (code) == 'd')
14557     {
14558       struct lang_decl *ld = DECL_LANG_SPECIFIC (t);
14559
14560       if (ld)
14561         {
14562           ggc_mark (ld);
14563           if (!DECL_GLOBAL_CTOR_P (t) && !DECL_GLOBAL_DTOR_P (t))
14564             ggc_mark_tree (ld->decl_flags.u2.access);
14565           ggc_mark_tree (ld->decl_flags.context);
14566           if (TREE_CODE (t) != NAMESPACE_DECL)
14567             ggc_mark_tree (ld->decl_flags.u.template_info);
14568           else
14569             mark_binding_level (&NAMESPACE_LEVEL (t));
14570           if (CAN_HAVE_FULL_LANG_DECL_P (t))
14571             {
14572               ggc_mark_tree (ld->main_decl_variant);
14573               ggc_mark_tree (ld->befriending_classes);
14574               ggc_mark_tree (ld->saved_tree);
14575               if (TREE_CODE (t) == TYPE_DECL)
14576                 ggc_mark_tree (ld->u.sorted_fields);
14577               else if (TREE_CODE (t) == FUNCTION_DECL
14578                        && !DECL_PENDING_INLINE_P (t))
14579                 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t));
14580             }
14581         }
14582     }
14583   else if (TREE_CODE_CLASS (code) == 't')
14584     {
14585       struct lang_type *lt = TYPE_LANG_SPECIFIC (t);
14586
14587       if (lt && !(TREE_CODE (t) == POINTER_TYPE
14588                   && TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE))
14589         {
14590           ggc_mark (lt);
14591           ggc_mark_tree (lt->vfields);
14592           ggc_mark_tree (lt->vbases);
14593           ggc_mark_tree (lt->tags);
14594           ggc_mark_tree (lt->search_slot);
14595           ggc_mark_tree (lt->size);
14596           ggc_mark_tree (lt->pure_virtuals);
14597           ggc_mark_tree (lt->friend_classes);
14598           ggc_mark_tree (lt->rtti);
14599           ggc_mark_tree (lt->methods);
14600           ggc_mark_tree (lt->template_info);
14601           ggc_mark_tree (lt->befriending_classes);
14602         }
14603       else if (lt)
14604         /* In the case of pointer-to-member function types, the
14605            TYPE_LANG_SPECIFIC is really just a tree.  */
14606         ggc_mark_tree ((tree) lt);
14607     }
14608 }