gcc/cp/decl.c

   1 /* Process declarations and variables for C compiler.
   2    Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000
   3    Free Software Foundation, Inc.
   4    Contributed by Michael Tiemann (tiemann@cygnus.com)
   5
   6 This file is part of GNU CC.
   7
   8 GNU CC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2, or (at your option)
  11 any later version.
  12
  13 GNU CC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GNU CC; see the file COPYING.  If not, write to
  20 the Free Software Foundation, 59 Temple Place - Suite 330,
  21 Boston, MA 02111-1307, USA.  */
  22
  23
  24 /* Process declarations and symbol lookup for C front end.
  25    Also constructs types; the standard scalar types at initialization,
  26    and structure, union, array and enum types when they are declared.  */
  27
  28 /* ??? not all decl nodes are given the most useful possible
  29    line numbers.  For example, the CONST_DECLs for enum values.  */
  30
  31 #include "config.h"
  32 #include "system.h"
  33 #include "tree.h"
  34 #include "rtl.h"
  35 #include "expr.h"
  36 #include "flags.h"
  37 #include "cp-tree.h"
  38 #include "decl.h"
  39 #include "lex.h"
  40 #include "defaults.h"
  41 #include "output.h"
  42 #include "except.h"
  43 #include "toplev.h"
  44 #include "../hash.h"
  45 #include "defaults.h"
  46 #include "ggc.h"
  47
  48 extern int current_class_depth;
  49
  50 extern tree static_ctors, static_dtors;
  51
  52 extern tree global_namespace;
  53
  54 extern int (*valid_lang_attribute) PARAMS ((tree, tree, tree, tree));
  55
  56 /* Use garbage collection.  */
  57
  58 int ggc_p = 1;
  59
  60 #ifndef WCHAR_UNSIGNED
  61 #define WCHAR_UNSIGNED 0
  62 #endif
  63
  64 #ifndef CHAR_TYPE_SIZE
  65 #define CHAR_TYPE_SIZE BITS_PER_UNIT
  66 #endif
  67
  68 #ifndef BOOL_TYPE_SIZE
  69 #ifdef SLOW_BYTE_ACCESS
  70 /* In the new ABI, `bool' has size and alignment `1', on all
  71    platforms.  */
  72 #define BOOL_TYPE_SIZE \
  73   ((SLOW_BYTE_ACCESS && !flag_new_abi) ? (POINTER_SIZE) : (CHAR_TYPE_SIZE))
  74 #else
  75 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
  76 #endif
  77 #endif
  78
  79 /* We let tm.h override the types used here, to handle trivial differences
  80    such as the choice of unsigned int or long unsigned int for size_t.
  81    When machines start needing nontrivial differences in the size type,
  82    it would be best to do something here to figure out automatically
  83    from other information what type to use.  */
  84
  85 #ifndef SIZE_TYPE
  86 #define SIZE_TYPE "long unsigned int"
  87 #endif
  88
  89 #ifndef PTRDIFF_TYPE
  90 #define PTRDIFF_TYPE "long int"
  91 #endif
  92
  93 #ifndef WCHAR_TYPE
  94 #define WCHAR_TYPE "int"
  95 #endif
  96
  97 static tree grokparms                           PARAMS ((tree, int));
  98 static const char *redeclaration_error_message  PARAMS ((tree, tree));
  99
 100 static void push_binding_level PARAMS ((struct binding_level *, int,
 101                                       int));
 102 static void pop_binding_level PARAMS ((void));
 103 static void suspend_binding_level PARAMS ((void));
 104 static void resume_binding_level PARAMS ((struct binding_level *));
 105 static struct binding_level *make_binding_level PARAMS ((void));
 106 static void declare_namespace_level PARAMS ((void));
 107 static int decl_jump_unsafe PARAMS ((tree));
 108 static void storedecls PARAMS ((tree));
 109 static void require_complete_types_for_parms PARAMS ((tree));
 110 static int ambi_op_p PARAMS ((enum tree_code));
 111 static int unary_op_p PARAMS ((enum tree_code));
 112 static tree store_bindings PARAMS ((tree, tree));
 113 static tree lookup_tag_reverse PARAMS ((tree, tree));
 114 static tree obscure_complex_init PARAMS ((tree, tree));
 115 static tree lookup_name_real PARAMS ((tree, int, int, int));
 116 static void warn_extern_redeclared_static PARAMS ((tree, tree));
 117 static void grok_reference_init PARAMS ((tree, tree, tree));
 118 static tree grokfndecl PARAMS ((tree, tree, tree, tree, int,
 119                               enum overload_flags, tree,
 120                               tree, int, int, int, int, int, int, tree));
 121 static tree grokvardecl PARAMS ((tree, tree, RID_BIT_TYPE *, int, int, tree));
 122 static tree lookup_tag PARAMS ((enum tree_code, tree,
 123                               struct binding_level *, int));
 124 static void set_identifier_type_value_with_scope
 125         PARAMS ((tree, tree, struct binding_level *));
 126 static void record_builtin_type PARAMS ((enum rid, const char *, tree));
 127 static void record_unknown_type PARAMS ((tree, const char *));
 128 static tree build_library_fn_1 PARAMS ((tree, enum tree_code, tree));
 129 static int member_function_or_else PARAMS ((tree, tree, enum overload_flags));
 130 static void bad_specifiers PARAMS ((tree, const char *, int, int, int, int,
 131                                   int));
 132 static tree maybe_process_template_type_declaration PARAMS ((tree, int, struct binding_level*));
 133 static void check_for_uninitialized_const_var PARAMS ((tree));
 134 static unsigned long typename_hash PARAMS ((hash_table_key));
 135 static boolean typename_compare PARAMS ((hash_table_key, hash_table_key));
 136 static void push_binding PARAMS ((tree, tree, struct binding_level*));
 137 static int add_binding PARAMS ((tree, tree));
 138 static void pop_binding PARAMS ((tree, tree));
 139 static tree local_variable_p_walkfn PARAMS ((tree *, int *, void *));
 140 static tree find_binding PARAMS ((tree, tree));
 141 static tree select_decl PARAMS ((tree, int));
 142 static int lookup_flags PARAMS ((int, int));
 143 static tree qualify_lookup PARAMS ((tree, int));
 144 static tree record_builtin_java_type PARAMS ((const char *, int));
 145 static const char *tag_name PARAMS ((enum tag_types code));
 146 static void find_class_binding_level PARAMS ((void));
 147 static struct binding_level *innermost_nonclass_level PARAMS ((void));
 148 static void warn_about_implicit_typename_lookup PARAMS ((tree, tree));
 149 static int walk_namespaces_r PARAMS ((tree, walk_namespaces_fn, void *));
 150 static int walk_globals_r PARAMS ((tree, void *));
 151 static void add_decl_to_level PARAMS ((tree, struct binding_level *));
 152 static tree make_label_decl PARAMS ((tree, int));
 153 static void use_label PARAMS ((tree));
 154 static void check_previous_goto_1 PARAMS ((tree, struct binding_level *, tree,
 155                                            const char *, int));
 156 static void check_previous_goto PARAMS ((struct named_label_use_list *));
 157 static void check_switch_goto PARAMS ((struct binding_level *));
 158 static void check_previous_gotos PARAMS ((tree));
 159 static void pop_label PARAMS ((tree, tree));
 160 static void pop_labels PARAMS ((tree));
 161 static void maybe_deduce_size_from_array_init PARAMS ((tree, tree));
 162 static void layout_var_decl PARAMS ((tree));
 163 static void maybe_commonize_var PARAMS ((tree));
 164 static tree check_initializer PARAMS ((tree, tree));
 165 static void make_rtl_for_nonlocal_decl PARAMS ((tree, tree, const char *));
 166 static void push_cp_function_context PARAMS ((struct function *));
 167 static void pop_cp_function_context PARAMS ((struct function *));
 168 static void mark_binding_level PARAMS ((void *));
 169 static void mark_named_label_lists PARAMS ((void *, 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 cp_language_function *));
 173 static void mark_stmt_tree PARAMS ((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 static tree cp_make_fname_decl PARAMS ((tree, const char *, int));
 185 static void initialize_predefined_identifiers PARAMS ((void));
 186 static tree check_special_function_return_type
 187   PARAMS ((special_function_kind, tree, tree, tree));
 188 static tree push_cp_library_fn PARAMS ((enum tree_code, tree));
 189 static tree build_cp_library_fn PARAMS ((tree, enum tree_code, tree));
 190 static int case_compare PARAMS ((splay_tree_key, splay_tree_key));
 191
 192 #if defined (DEBUG_CP_BINDING_LEVELS)
 193 static void indent PARAMS ((void));
 194 #endif
 195
 196 /* Erroneous argument lists can use this *IFF* they do not modify it.  */
 197 tree error_mark_list;
 198
 199 /* The following symbols are subsumed in the cp_global_trees array, and
 200    listed here individually for documentation purposes.
 201
 202    C++ extensions
 203         tree wchar_decl_node;
 204
 205         tree vtable_entry_type;
 206         tree delta_type_node;
 207 #if 0
 208    Old rtti stuff.
 209         tree __baselist_desc_type_node;
 210         tree __i_desc_type_node, __m_desc_type_node;
 211         tree __t_desc_array_type, __i_desc_array_type, __m_desc_array_type;
 212 #endif
 213         tree __t_desc_type_node;
 214 #if 0
 215         tree __tp_desc_type_node;
 216 #endif
 217         tree ti_desc_type_node;
 218         tree bltn_desc_type_node, ptr_desc_type_node;
 219         tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
 220         tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
 221         tree ptm_desc_type_node;
 222         tree base_desc_type_node;
 223 #if 0
 224    Not needed yet?  May be needed one day?
 225         tree __bltn_desc_array_type, __user_desc_array_type, __class_desc_array_type;
 226         tree __ptr_desc_array_type, __attr_dec_array_type, __func_desc_array_type;
 227         tree __ptmf_desc_array_type, __ptmd_desc_array_type;
 228 #endif
 229
 230         tree class_type_node, record_type_node, union_type_node, enum_type_node;
 231         tree unknown_type_node;
 232
 233    Array type `vtable_entry_type[]'
 234
 235         tree vtbl_type_node;
 236         tree vtbl_ptr_type_node;
 237
 238    Namespaces,
 239
 240         tree std_node;
 241         tree abi_node;
 242
 243    A FUNCTION_DECL which can call `abort'.  Not necessarily the
 244    one that the user will declare, but sufficient to be called
 245    by routines that want to abort the program.
 246
 247         tree abort_fndecl;
 248
 249    The FUNCTION_DECL for the default `::operator delete'.
 250
 251         tree global_delete_fndecl;
 252
 253    Used by RTTI
 254         tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
 255         tree tinfo_var_id;
 256
 257 */
 258
 259 tree cp_global_trees[CPTI_MAX];
 260
 261 /* Indicates that there is a type value in some namespace, although
 262    that is not necessarily in scope at the moment.  */
 263
 264 static tree global_type_node;
 265
 266 /* Namespace std.  */
 267 int in_std;
 268
 269 /* Expect only namespace names now. */
 270 static int only_namespace_names;
 271
 272 /* Used only for jumps to as-yet undefined labels, since jumps to
 273    defined labels can have their validity checked immediately.  */
 274
 275 struct named_label_use_list
 276 {
 277   struct binding_level *binding_level;
 278   tree names_in_scope;
 279   tree label_decl;
 280   const char *filename_o_goto;
 281   int lineno_o_goto;
 282   struct named_label_use_list *next;
 283 };
 284
 285 #define named_label_uses cp_function_chain->x_named_label_uses
 286
 287 /* A list of objects which have constructors or destructors
 288    which reside in the global scope.  The decl is stored in
 289    the TREE_VALUE slot and the initializer is stored
 290    in the TREE_PURPOSE slot.  */
 291 tree static_aggregates;
 292
 293 /* -- end of C++ */
 294
 295 /* A node for the integer constants 2, and 3.  */
 296
 297 tree integer_two_node, integer_three_node;
 298
 299 /* Parsing a function declarator leaves here a chain of structure
 300    and enum types declared in the parmlist.  */
 301
 302 static tree last_function_parm_tags;
 303
 304 /* Similar, for last_function_parm_tags.  */
 305 tree last_function_parms;
 306 static tree current_function_parm_tags;
 307
 308 /* A list of all LABEL_DECLs in the function that have names.  Here so
 309    we can clear out their names' definitions at the end of the
 310    function, and so we can check the validity of jumps to these labels.  */
 311
 312 struct named_label_list
 313 {
 314   struct binding_level *binding_level;
 315   tree names_in_scope;
 316   tree old_value;
 317   tree label_decl;
 318   tree bad_decls;
 319   int eh_region;
 320   struct named_label_list *next;
 321 };
 322
 323 #define named_labels cp_function_chain->x_named_labels
 324
 325 /* Set to 0 at beginning of a function definition, and whenever
 326    a label (case or named) is defined.  Set to value of expression
 327    returned from function when that value can be transformed into
 328    a named return value.  */
 329
 330 tree current_function_return_value;
 331
 332 /* Nonzero means use the ISO C94 dialect of C.  */
 333
 334 int flag_isoc94;
 335
 336 /* Nonzero means use the ISO C99 dialect of C.  */
 337
 338 int flag_isoc99;
 339
 340 /* Nonzero means we are a hosted implementation for code shared with C.  */
 341
 342 int flag_hosted = 1;
 343
 344 /* Nonzero means add default format_arg attributes for functions not
 345    in ISO C.  */
 346
 347 int flag_noniso_default_format_attributes = 1;
 348
 349 /* Nonzero means give `double' the same size as `float'.  */
 350
 351 extern int flag_short_double;
 352
 353 /* Nonzero means don't recognize any builtin functions.  */
 354
 355 extern int flag_no_builtin;
 356
 357 /* Nonzero means don't recognize the non-ANSI builtin functions.
 358    -ansi sets this.  */
 359
 360 extern int flag_no_nonansi_builtin;
 361
 362 /* Nonzero if we want to conserve space in the .o files.  We do this
 363    by putting uninitialized data and runtime initialized data into
 364    .common instead of .data at the expense of not flagging multiple
 365    definitions.  */
 366 extern int flag_conserve_space;
 367 \f
 368 /* C and C++ flags are in decl2.c.  */
 369
 370 /* Flag used when debugging spew.c */
 371
 372 extern int spew_debug;
 373
 374 /* A expression of value 0 with the same precision as a sizetype
 375    node, but signed.  */
 376 tree signed_size_zero_node;
 377
 378 /* The name of the anonymous namespace, throughout this translation
 379    unit.  */
 380 tree anonymous_namespace_name;
 381
 382 /* The number of function bodies which we are currently processing.
 383    (Zero if we are at namespace scope, one inside the body of a
 384    function, two inside the body of a function in a local class, etc.)  */
 385 int function_depth;
 386 \f
 387 /* For each binding contour we allocate a binding_level structure
 388    which records the names defined in that contour.
 389    Contours include:
 390     0) the global one
 391     1) one for each function definition,
 392        where internal declarations of the parameters appear.
 393     2) one for each compound statement,
 394        to record its declarations.
 395
 396    The current meaning of a name can be found by searching the levels
 397    from the current one out to the global one.
 398
 399    Off to the side, may be the class_binding_level.  This exists only
 400    to catch class-local declarations.  It is otherwise nonexistent.
 401
 402    Also there may be binding levels that catch cleanups that must be
 403    run when exceptions occur.  Thus, to see whether a name is bound in
 404    the current scope, it is not enough to look in the
 405    CURRENT_BINDING_LEVEL.  You should use lookup_name_current_level
 406    instead.  */
 407
 408 /* Note that the information in the `names' component of the global contour
 409    is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers.  */
 410
 411 struct binding_level
 412   {
 413     /* A chain of _DECL nodes for all variables, constants, functions,
 414        and typedef types.  These are in the reverse of the order
 415        supplied.  There may be OVERLOADs on this list, too, but they
 416        are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD.  */
 417     tree names;
 418
 419     /* A list of structure, union and enum definitions, for looking up
 420        tag names.
 421        It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
 422        or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
 423        or ENUMERAL_TYPE node.
 424
 425        C++: the TREE_VALUE nodes can be simple types for
 426        component_bindings.  */
 427     tree tags;
 428
 429     /* A list of USING_DECL nodes. */
 430     tree usings;
 431
 432     /* A list of used namespaces. PURPOSE is the namespace,
 433        VALUE the common ancestor with this binding_level's namespace. */
 434     tree using_directives;
 435
 436     /* If this binding level is the binding level for a class, then
 437        class_shadowed is a TREE_LIST.  The TREE_PURPOSE of each node
 438        is the name of an entity bound in the class; the TREE_VALUE is
 439        the IDENTIFIER_CLASS_VALUE before we entered the class.  Thus,
 440        when leaving class scope, we can restore the
 441        IDENTIFIER_CLASS_VALUE by walking this list.  The TREE_TYPE is
 442        the DECL bound by this name in the class.  */
 443     tree class_shadowed;
 444
 445     /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
 446        is used for all binding levels.  */
 447     tree type_shadowed;
 448
 449     /* A TREE_LIST.  Each TREE_VALUE is the LABEL_DECL for a local
 450        label in this scope.  The TREE_PURPOSE is the previous value of
 451        the IDENTIFIER_LABEL VALUE.  */
 452     tree shadowed_labels;
 453
 454     /* For each level (except not the global one),
 455        a chain of BLOCK nodes for all the levels
 456        that were entered and exited one level down.  */
 457     tree blocks;
 458
 459     /* The BLOCK node for this level, if one has been preallocated.
 460        If 0, the BLOCK is allocated (if needed) when the level is popped.  */
 461     tree this_block;
 462
 463     /* The _TYPE node for this level, if parm_flag == 2.  */
 464     tree this_class;
 465
 466     /* The binding level which this one is contained in (inherits from).  */
 467     struct binding_level *level_chain;
 468
 469     /* List of decls in `names' that have incomplete
 470        structure or union types.  */
 471     tree incomplete;
 472
 473     /* List of VAR_DECLS saved from a previous for statement.
 474        These would be dead in ISO-conforming code, but might
 475        be referenced in ARM-era code.  These are stored in a
 476        TREE_LIST; the TREE_VALUE is the actual declaration.  */
 477     tree dead_vars_from_for;
 478
 479     /* 1 for the level that holds the parameters of a function.
 480        2 for the level that holds a class declaration.  */
 481     unsigned parm_flag : 2;
 482
 483     /* 1 means make a BLOCK for this level regardless of all else.
 484        2 for temporary binding contours created by the compiler.  */
 485     unsigned keep : 2;
 486
 487     /* Nonzero if this level "doesn't exist" for tags.  */
 488     unsigned tag_transparent : 1;
 489
 490     /* Nonzero if this level can safely have additional
 491        cleanup-needing variables added to it.  */
 492     unsigned more_cleanups_ok : 1;
 493     unsigned have_cleanups : 1;
 494
 495     /* Nonzero if this scope is for storing the decls for template
 496        parameters and generic decls; these decls will be discarded and
 497        replaced with a TEMPLATE_DECL.  */
 498     unsigned template_parms_p : 1;
 499
 500     /* Nonzero if this scope corresponds to the `<>' in a
 501        `template <>' clause.  Whenever this flag is set,
 502        TEMPLATE_PARMS_P will be set as well.  */
 503     unsigned template_spec_p : 1;
 504
 505     /* This is set for a namespace binding level.  */
 506     unsigned namespace_p : 1;
 507
 508     /* True if this level is that of a for-statement where we need to
 509        worry about ambiguous (ARM or ISO) scope rules.  */
 510     unsigned is_for_scope : 1;
 511
 512     /* True if this level corresponds to an EH region, as for a try block.
 513        Currently this information is only available while building the
 514        tree structure.  */
 515     unsigned eh_region : 1;
 516
 517     /* Four bits left for this word.  */
 518
 519 #if defined(DEBUG_CP_BINDING_LEVELS)
 520     /* Binding depth at which this level began.  */
 521     unsigned binding_depth;
 522 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 523   };
 524
 525 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
 526
 527 /* The binding level currently in effect.  */
 528
 529 #define current_binding_level                   \
 530   (cfun                                         \
 531    ? cp_function_chain->bindings                \
 532    : scope_chain->bindings)
 533
 534 /* The binding level of the current class, if any.  */
 535
 536 #define class_binding_level scope_chain->class_bindings
 537
 538 /* A chain of binding_level structures awaiting reuse.  */
 539
 540 static struct binding_level *free_binding_level;
 541
 542 /* The outermost binding level, for names of file scope.
 543    This is created when the compiler is started and exists
 544    through the entire run.  */
 545
 546 static struct binding_level *global_binding_level;
 547
 548 /* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
 549
 550 static int keep_next_level_flag;
 551
 552 #if defined(DEBUG_CP_BINDING_LEVELS)
 553 static int binding_depth = 0;
 554 static int is_class_level = 0;
 555
 556 static void
 557 indent ()
 558 {
 559   register unsigned i;
 560
 561   for (i = 0; i < binding_depth*2; i++)
 562     putc (' ', stderr);
 563 }
 564 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 565
 566 static tree pushdecl_with_scope PARAMS ((tree, struct binding_level *));
 567
 568 static void
 569 push_binding_level (newlevel, tag_transparent, keep)
 570      struct binding_level *newlevel;
 571      int tag_transparent, keep;
 572 {
 573   /* Add this level to the front of the chain (stack) of levels that
 574      are active.  */
 575   bzero ((char*) newlevel, sizeof (struct binding_level));
 576   newlevel->level_chain = current_binding_level;
 577   current_binding_level = newlevel;
 578   newlevel->tag_transparent = tag_transparent;
 579   newlevel->more_cleanups_ok = 1;
 580
 581   newlevel->keep = keep;
 582 #if defined(DEBUG_CP_BINDING_LEVELS)
 583   newlevel->binding_depth = binding_depth;
 584   indent ();
 585   fprintf (stderr, "push %s level 0x%08x line %d\n",
 586            (is_class_level) ? "class" : "block", newlevel, lineno);
 587   is_class_level = 0;
 588   binding_depth++;
 589 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 590 }
 591
 592 /* Find the innermost enclosing class scope, and reset
 593    CLASS_BINDING_LEVEL appropriately.  */
 594
 595 static void
 596 find_class_binding_level ()
 597 {
 598   struct binding_level *level = current_binding_level;
 599
 600   while (level && level->parm_flag != 2)
 601     level = level->level_chain;
 602   if (level && level->parm_flag == 2)
 603     class_binding_level = level;
 604   else
 605     class_binding_level = 0;
 606 }
 607
 608 static void
 609 pop_binding_level ()
 610 {
 611   if (global_binding_level)
 612     {
 613       /* Cannot pop a level, if there are none left to pop.  */
 614       if (current_binding_level == global_binding_level)
 615         my_friendly_abort (123);
 616     }
 617   /* Pop the current level, and free the structure for reuse.  */
 618 #if defined(DEBUG_CP_BINDING_LEVELS)
 619   binding_depth--;
 620   indent ();
 621   fprintf (stderr, "pop  %s level 0x%08x line %d\n",
 622           (is_class_level) ? "class" : "block",
 623           current_binding_level, lineno);
 624   if (is_class_level != (current_binding_level == class_binding_level))
 625     {
 626       indent ();
 627       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 628     }
 629   is_class_level = 0;
 630 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 631   {
 632     register struct binding_level *level = current_binding_level;
 633     current_binding_level = current_binding_level->level_chain;
 634     level->level_chain = free_binding_level;
 635 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
 636     if (level->binding_depth != binding_depth)
 637       abort ();
 638 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 639     free_binding_level = level;
 640     find_class_binding_level ();
 641   }
 642 }
 643
 644 static void
 645 suspend_binding_level ()
 646 {
 647   if (class_binding_level)
 648     current_binding_level = class_binding_level;
 649
 650   if (global_binding_level)
 651     {
 652       /* Cannot suspend a level, if there are none left to suspend.  */
 653       if (current_binding_level == global_binding_level)
 654         my_friendly_abort (123);
 655     }
 656   /* Suspend the current level.  */
 657 #if defined(DEBUG_CP_BINDING_LEVELS)
 658   binding_depth--;
 659   indent ();
 660   fprintf (stderr, "suspend  %s level 0x%08x line %d\n",
 661           (is_class_level) ? "class" : "block",
 662           current_binding_level, lineno);
 663   if (is_class_level != (current_binding_level == class_binding_level))
 664     {
 665       indent ();
 666       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 667     }
 668   is_class_level = 0;
 669 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 670   current_binding_level = current_binding_level->level_chain;
 671   find_class_binding_level ();
 672 }
 673
 674 static void
 675 resume_binding_level (b)
 676      struct binding_level *b;
 677 {
 678   /* Resuming binding levels is meant only for namespaces,
 679      and those cannot nest into classes. */
 680   my_friendly_assert(!class_binding_level, 386);
 681   /* Also, resuming a non-directly nested namespace is a no-no.  */
 682   my_friendly_assert(b->level_chain == current_binding_level, 386);
 683   current_binding_level = b;
 684 #if defined(DEBUG_CP_BINDING_LEVELS)
 685   b->binding_depth = binding_depth;
 686   indent ();
 687   fprintf (stderr, "resume %s level 0x%08x line %d\n",
 688            (is_class_level) ? "class" : "block", b, lineno);
 689   is_class_level = 0;
 690   binding_depth++;
 691 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 692 }
 693 \f
 694 /* Create a new `struct binding_level'.  */
 695
 696 static
 697 struct binding_level *
 698 make_binding_level ()
 699 {
 700   /* NOSTRICT */
 701   return (struct binding_level *) xmalloc (sizeof (struct binding_level));
 702 }
 703
 704 /* Nonzero if we are currently in the global binding level.  */
 705
 706 int
 707 global_bindings_p ()
 708 {
 709   return current_binding_level == global_binding_level;
 710 }
 711
 712 /* Return the innermost binding level that is not for a class scope.  */
 713
 714 static struct binding_level *
 715 innermost_nonclass_level ()
 716 {
 717   struct binding_level *b;
 718
 719   b = current_binding_level;
 720   while (b->parm_flag == 2)
 721     b = b->level_chain;
 722
 723   return b;
 724 }
 725
 726 /* Nonzero if we are currently in a toplevel binding level.  This
 727    means either the global binding level or a namespace in a toplevel
 728    binding level.  Since there are no non-toplevel namespace levels,
 729    this really means any namespace or template parameter level.  We
 730    also include a class whose context is toplevel.  */
 731
 732 int
 733 toplevel_bindings_p ()
 734 {
 735   struct binding_level *b = innermost_nonclass_level ();
 736
 737   return b->namespace_p || b->template_parms_p;
 738 }
 739
 740 /* Nonzero if this is a namespace scope, or if we are defining a class
 741    which is itself at namespace scope, or whose enclosing class is
 742    such a class, etc.  */
 743
 744 int
 745 namespace_bindings_p ()
 746 {
 747   struct binding_level *b = innermost_nonclass_level ();
 748
 749   return b->namespace_p;
 750 }
 751
 752 /* If KEEP is non-zero, make a BLOCK node for the next binding level,
 753    unconditionally.  Otherwise, use the normal logic to decide whether
 754    or not to create a BLOCK.  */
 755
 756 void
 757 keep_next_level (keep)
 758      int keep;
 759 {
 760   keep_next_level_flag = keep;
 761 }
 762
 763 /* Nonzero if the current level needs to have a BLOCK made.  */
 764
 765 int
 766 kept_level_p ()
 767 {
 768   return (current_binding_level->blocks != NULL_TREE
 769           || current_binding_level->keep
 770           || current_binding_level->names != NULL_TREE
 771           || (current_binding_level->tags != NULL_TREE
 772               && !current_binding_level->tag_transparent));
 773 }
 774
 775 static void
 776 declare_namespace_level ()
 777 {
 778   current_binding_level->namespace_p = 1;
 779 }
 780
 781 /* Returns non-zero if this scope was created to store template
 782    parameters.  */
 783
 784 int
 785 template_parm_scope_p ()
 786 {
 787   return current_binding_level->template_parms_p;
 788 }
 789
 790 /* Returns the kind of template specialization we are currently
 791    processing, given that it's declaration contained N_CLASS_SCOPES
 792    explicit scope qualifications.  */
 793
 794 tmpl_spec_kind
 795 current_tmpl_spec_kind (n_class_scopes)
 796      int n_class_scopes;
 797 {
 798   int n_template_parm_scopes = 0;
 799   int seen_specialization_p = 0;
 800   int innermost_specialization_p = 0;
 801   struct binding_level *b;
 802
 803   /* Scan through the template parameter scopes.  */
 804   for (b = current_binding_level; b->template_parms_p; b = b->level_chain)
 805     {
 806       /* If we see a specialization scope inside a parameter scope,
 807          then something is wrong.  That corresponds to a declaration
 808          like:
 809
 810             template <class T> template <> ...
 811
 812          which is always illegal since [temp.expl.spec] forbids the
 813          specialization of a class member template if the enclosing
 814          class templates are not explicitly specialized as well.  */
 815       if (b->template_spec_p)
 816         {
 817           if (n_template_parm_scopes == 0)
 818             innermost_specialization_p = 1;
 819           else
 820             seen_specialization_p = 1;
 821         }
 822       else if (seen_specialization_p == 1)
 823         return tsk_invalid_member_spec;
 824
 825       ++n_template_parm_scopes;
 826     }
 827
 828   /* Handle explicit instantiations.  */
 829   if (processing_explicit_instantiation)
 830     {
 831       if (n_template_parm_scopes != 0)
 832         /* We've seen a template parameter list during an explicit
 833            instantiation.  For example:
 834
 835              template <class T> template void f(int);
 836
 837            This is erroneous.  */
 838         return tsk_invalid_expl_inst;
 839       else
 840         return tsk_expl_inst;
 841     }
 842
 843   if (n_template_parm_scopes < n_class_scopes)
 844     /* We've not seen enough template headers to match all the
 845        specialized classes present.  For example:
 846
 847          template <class T> void R<T>::S<T>::f(int);
 848
 849        This is illegal; there needs to be one set of template
 850        parameters for each class.  */
 851     return tsk_insufficient_parms;
 852   else if (n_template_parm_scopes == n_class_scopes)
 853     /* We're processing a non-template declaration (even though it may
 854        be a member of a template class.)  For example:
 855
 856          template <class T> void S<T>::f(int);
 857
 858        The `class T' maches the `S<T>', leaving no template headers
 859        corresponding to the `f'.  */
 860     return tsk_none;
 861   else if (n_template_parm_scopes > n_class_scopes + 1)
 862     /* We've got too many template headers.  For example:
 863
 864          template <> template <class T> void f (T);
 865
 866        There need to be more enclosing classes.  */
 867     return tsk_excessive_parms;
 868   else
 869     /* This must be a template.  It's of the form:
 870
 871          template <class T> template <class U> void S<T>::f(U);
 872
 873        This is a specialization if the innermost level was a
 874        specialization; otherwise it's just a definition of the
 875        template.  */
 876     return innermost_specialization_p ? tsk_expl_spec : tsk_template;
 877 }
 878
 879 void
 880 set_class_shadows (shadows)
 881      tree shadows;
 882 {
 883   class_binding_level->class_shadowed = shadows;
 884 }
 885
 886 /* Enter a new binding level.
 887    If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
 888    not for that of tags.  */
 889
 890 void
 891 pushlevel (tag_transparent)
 892      int tag_transparent;
 893 {
 894   struct binding_level *newlevel;
 895
 896   if (cfun && !doing_semantic_analysis_p ())
 897     return;
 898
 899   /* Reuse or create a struct for this binding level.  */
 900 #if defined(DEBUG_CP_BINDING_LEVELS)
 901   if (0)
 902 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
 903   if (free_binding_level)
 904 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
 905     {
 906       newlevel = free_binding_level;
 907       free_binding_level = free_binding_level->level_chain;
 908     }
 909   else
 910     newlevel = make_binding_level ();
 911
 912   push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
 913   GNU_xref_start_scope ((HOST_WIDE_INT) newlevel);
 914   keep_next_level_flag = 0;
 915 }
 916
 917 /* Enter a new scope.  The KIND indicates what kind of scope is being
 918    created.  */
 919
 920 void
 921 begin_scope (sk)
 922      scope_kind sk;
 923 {
 924   pushlevel (0);
 925
 926   switch (sk)
 927     {
 928     case sk_template_spec:
 929       current_binding_level->template_spec_p = 1;
 930       /* Fall through.  */
 931
 932     case sk_template_parms:
 933       current_binding_level->template_parms_p = 1;
 934       break;
 935
 936     default:
 937       my_friendly_abort (20000309);
 938     }
 939 }
 940
 941 /* Exit the current scope.  */
 942
 943 void
 944 finish_scope ()
 945 {
 946   poplevel (0, 0, 0);
 947 }
 948
 949 void
 950 note_level_for_for ()
 951 {
 952   current_binding_level->is_for_scope = 1;
 953 }
 954
 955 /* Record that the current binding level represents a try block.  */
 956
 957 void
 958 note_level_for_eh ()
 959 {
 960   current_binding_level->eh_region = 1;
 961 }
 962
 963 /* For a binding between a name and an entity at a block scope,
 964    this is the `struct binding_level' for the block.  */
 965 #define BINDING_LEVEL(NODE) \
 966    (((struct tree_binding*)NODE)->scope.level)
 967
 968 /* Make DECL the innermost binding for ID.  The LEVEL is the binding
 969    level at which this declaration is being bound.  */
 970
 971 static void
 972 push_binding (id, decl, level)
 973      tree id;
 974      tree decl;
 975      struct binding_level* level;
 976 {
 977   tree binding;
 978
 979   binding = make_node (CPLUS_BINDING);
 980
 981   /* Now, fill in the binding information.  */
 982   BINDING_VALUE (binding) = decl;
 983   BINDING_TYPE (binding) = NULL_TREE;
 984   BINDING_LEVEL (binding) = level;
 985   INHERITED_VALUE_BINDING_P (binding) = 0;
 986   LOCAL_BINDING_P (binding) = (level != class_binding_level);
 987   BINDING_HAS_LEVEL_P (binding) = 1;
 988
 989   /* And put it on the front of the list of bindings for ID.  */
 990   TREE_CHAIN (binding) = IDENTIFIER_BINDING (id);
 991   IDENTIFIER_BINDING (id) = binding;
 992 }
 993
 994 /* ID is already bound in the current scope.  But, DECL is an
 995    additional binding for ID in the same scope.  This is the `struct
 996    stat' hack whereby a non-typedef class-name or enum-name can be
 997    bound at the same level as some other kind of entity.  It's the
 998    responsibility of the caller to check that inserting this name is
 999    legal here.  Returns nonzero if the new binding was successful.  */
1000 static int
1001 add_binding (id, decl)
1002      tree id;
1003      tree decl;
1004 {
1005   tree binding = IDENTIFIER_BINDING (id);
1006   int ok = 1;
1007
1008   if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
1009     /* The new name is the type name.  */
1010     BINDING_TYPE (binding) = decl;
1011   else if (!BINDING_VALUE (binding))
1012     /* This situation arises when push_class_level_binding moves an
1013        inherited type-binding out of the way to make room for a new
1014        value binding.  */
1015     BINDING_VALUE (binding) = decl;
1016   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
1017            && DECL_ARTIFICIAL (BINDING_VALUE (binding)))
1018     {
1019       /* The old binding was a type name.  It was placed in
1020          BINDING_VALUE because it was thought, at the point it was
1021          declared, to be the only entity with such a name.  Move the
1022          type name into the type slot; it is now hidden by the new
1023          binding.  */
1024       BINDING_TYPE (binding) = BINDING_VALUE (binding);
1025       BINDING_VALUE (binding) = decl;
1026       INHERITED_VALUE_BINDING_P (binding) = 0;
1027     }
1028   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
1029            && TREE_CODE (decl) == TYPE_DECL
1030            && DECL_NAME (decl) == DECL_NAME (BINDING_VALUE (binding))
1031            && same_type_p (TREE_TYPE (decl),
1032                            TREE_TYPE (BINDING_VALUE (binding))))
1033     /* We have two typedef-names, both naming the same type to have
1034        the same name.  This is OK because of:
1035
1036          [dcl.typedef]
1037
1038          In a given scope, a typedef specifier can be used to redefine
1039          the name of any type declared in that scope to refer to the
1040          type to which it already refers.  */
1041     ok = 0;
1042   /* There can be two block-scope declarations of the same variable,
1043      so long as they are `extern' declarations.  */
1044   else if (TREE_CODE (decl) == VAR_DECL
1045            && TREE_CODE (BINDING_VALUE (binding)) == VAR_DECL
1046            && DECL_EXTERNAL (decl)
1047            && DECL_EXTERNAL (BINDING_VALUE (binding)))
1048     {
1049       duplicate_decls (decl, BINDING_VALUE (binding));
1050       ok = 0;
1051     }
1052   else
1053     {
1054       cp_error ("declaration of `%#D'", decl);
1055       cp_error_at ("conflicts with previous declaration `%#D'",
1056                    BINDING_VALUE (binding));
1057       ok = 0;
1058     }
1059
1060   return ok;
1061 }
1062
1063 /* Add DECL to the list of things declared in B.  */
1064
1065 static void
1066 add_decl_to_level (decl, b)
1067      tree decl;
1068      struct binding_level *b;
1069 {
1070   /* We build up the list in reverse order, and reverse it later if
1071      necessary.  */
1072   TREE_CHAIN (decl) = b->names;
1073   b->names = decl;
1074 }
1075
1076 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1077    binding level.  If PUSH_USING is set in FLAGS, we know that DECL
1078    doesn't really belong to this binding level, that it got here
1079    through a using-declaration.  */
1080
1081 void
1082 push_local_binding (id, decl, flags)
1083      tree id;
1084      tree decl;
1085      int flags;
1086 {
1087   struct binding_level *b;
1088
1089   /* Skip over any local classes.  This makes sense if we call
1090      push_local_binding with a friend decl of a local class.  */
1091   b = current_binding_level;
1092   while (b->parm_flag == 2)
1093     b = b->level_chain;
1094
1095   if (lookup_name_current_level (id))
1096     {
1097       /* Supplement the existing binding.  */
1098       if (!add_binding (id, decl))
1099         /* It didn't work.  Something else must be bound at this
1100            level.  Do not add DECL to the list of things to pop
1101            later.  */
1102         return;
1103     }
1104   else
1105     /* Create a new binding.  */
1106     push_binding (id, decl, b);
1107
1108   if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1109     /* We must put the OVERLOAD into a TREE_LIST since the
1110        TREE_CHAIN of an OVERLOAD is already used.  Similarly for
1111        decls that got here through a using-declaration.  */
1112     decl = build_tree_list (NULL_TREE, decl);
1113
1114   /* And put DECL on the list of things declared by the current
1115      binding level.  */
1116   add_decl_to_level (decl, b);
1117 }
1118
1119 /* Bind DECL to ID in the class_binding_level.  Returns nonzero if the
1120    binding was successful.  */
1121
1122 int
1123 push_class_binding (id, decl)
1124      tree id;
1125      tree decl;
1126 {
1127   int result = 1;
1128   tree binding = IDENTIFIER_BINDING (id);
1129   tree context;
1130
1131   /* Note that we declared this value so that we can issue an error if
1132      this an illegal redeclaration of a name already used for some
1133      other purpose.  */
1134   note_name_declared_in_class (id, decl);
1135
1136   if (binding && BINDING_LEVEL (binding) == class_binding_level)
1137     /* Supplement the existing binding.  */
1138     result = add_binding (id, decl);
1139   else
1140     /* Create a new binding.  */
1141     push_binding (id, decl, class_binding_level);
1142
1143   /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1144      class-level declaration.  Note that we do not use DECL here
1145      because of the possibility of the `struct stat' hack; if DECL is
1146      a class-name or enum-name we might prefer a field-name, or some
1147      such.  */
1148   IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
1149
1150   /* If this is a binding from a base class, mark it as such.  */
1151   binding = IDENTIFIER_BINDING (id);
1152   if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
1153     {
1154       /* Any implicit typename must be from a base-class.  The
1155          context for an implicit typename declaration is always
1156          the derived class in which the lookup was done, so the checks
1157          based on the context of DECL below will not trigger.  */
1158       if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl))
1159         INHERITED_VALUE_BINDING_P (binding) = 1;
1160       else
1161         {
1162           if (TREE_CODE (decl) == OVERLOAD)
1163             context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
1164           else
1165             {
1166               my_friendly_assert (DECL_P (decl), 0);
1167               context = CP_DECL_CONTEXT (decl);
1168             }
1169
1170           if (is_properly_derived_from (current_class_type, context))
1171             INHERITED_VALUE_BINDING_P (binding) = 1;
1172           else
1173             INHERITED_VALUE_BINDING_P (binding) = 0;
1174         }
1175     }
1176   else if (BINDING_VALUE (binding) == decl)
1177     /* We only encounter a TREE_LIST when push_class_decls detects an
1178        ambiguity.  Such an ambiguity can be overridden by a definition
1179        in this class.  */
1180     INHERITED_VALUE_BINDING_P (binding) = 1;
1181
1182   return result;
1183 }
1184
1185 /* Remove the binding for DECL which should be the innermost binding
1186    for ID.  */
1187
1188 static void
1189 pop_binding (id, decl)
1190      tree id;
1191      tree decl;
1192 {
1193   tree binding;
1194
1195   if (id == NULL_TREE)
1196     /* It's easiest to write the loops that call this function without
1197        checking whether or not the entities involved have names.  We
1198        get here for such an entity.  */
1199     return;
1200
1201   /* Get the innermost binding for ID.  */
1202   binding = IDENTIFIER_BINDING (id);
1203
1204   /* The name should be bound.  */
1205   my_friendly_assert (binding != NULL_TREE, 0);
1206
1207   /* The DECL will be either the ordinary binding or the type
1208      binding for this identifier.  Remove that binding.  */
1209   if (BINDING_VALUE (binding) == decl)
1210     BINDING_VALUE (binding) = NULL_TREE;
1211   else if (BINDING_TYPE (binding) == decl)
1212     BINDING_TYPE (binding) = NULL_TREE;
1213   else
1214     my_friendly_abort (0);
1215
1216   if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
1217     /* We're completely done with the innermost binding for this
1218        identifier.  Unhook it from the list of bindings.  */
1219     IDENTIFIER_BINDING (id) = TREE_CHAIN (binding);
1220 }
1221
1222 /* When a label goes out of scope, check to see if that label was used
1223    in a valid manner, and issue any appropriate warnings or errors.  */
1224
1225 static void
1226 pop_label (label, old_value)
1227      tree label;
1228      tree old_value;
1229 {
1230   if (!processing_template_decl && doing_semantic_analysis_p ())
1231     {
1232       if (DECL_INITIAL (label) == NULL_TREE)
1233         {
1234           cp_error_at ("label `%D' used but not defined", label);
1235           /* Avoid crashing later.  */
1236           define_label (input_filename, 1, DECL_NAME (label));
1237         }
1238       else if (warn_unused_label && !TREE_USED (label))
1239         cp_warning_at ("label `%D' defined but not used", label);
1240     }
1241
1242   SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
1243 }
1244
1245 /* At the end of a function, all labels declared within the function
1246    go out of scope.  BLOCK is the top-level block for the
1247    function.  */
1248
1249 static void
1250 pop_labels (block)
1251      tree block;
1252 {
1253   struct named_label_list *link;
1254
1255   /* Clear out the definitions of all label names, since their scopes
1256      end here.  */
1257   for (link = named_labels; link; link = link->next)
1258     {
1259       pop_label (link->label_decl, link->old_value);
1260       /* Put the labels into the "variables" of the top-level block,
1261          so debugger can see them.  */
1262       TREE_CHAIN (link->label_decl) = BLOCK_VARS (block);
1263       BLOCK_VARS (block) = link->label_decl;
1264     }
1265
1266   named_labels = NULL;
1267 }
1268
1269 /* Exit a binding level.
1270    Pop the level off, and restore the state of the identifier-decl mappings
1271    that were in effect when this level was entered.
1272
1273    If KEEP == 1, this level had explicit declarations, so
1274    and create a "block" (a BLOCK node) for the level
1275    to record its declarations and subblocks for symbol table output.
1276
1277    If FUNCTIONBODY is nonzero, this level is the body of a function,
1278    so create a block as if KEEP were set and also clear out all
1279    label names.
1280
1281    If REVERSE is nonzero, reverse the order of decls before putting
1282    them into the BLOCK.  */
1283
1284 tree
1285 poplevel (keep, reverse, functionbody)
1286      int keep;
1287      int reverse;
1288      int functionbody;
1289 {
1290   register tree link;
1291   /* The chain of decls was accumulated in reverse order.
1292      Put it into forward order, just for cleanliness.  */
1293   tree decls;
1294   int tmp = functionbody;
1295   int real_functionbody;
1296   tree tags;
1297   tree subblocks;
1298   tree block = NULL_TREE;
1299   tree decl;
1300   int block_previously_created;
1301   int leaving_for_scope;
1302
1303   if (cfun && !doing_semantic_analysis_p ())
1304     return NULL_TREE;
1305
1306   my_friendly_assert (current_binding_level->parm_flag != 2,
1307                       19990916);
1308
1309   real_functionbody = (current_binding_level->keep == 2
1310                        ? ((functionbody = 0), tmp) : functionbody);
1311   tags = functionbody >= 0 ? current_binding_level->tags : 0;
1312   subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1313
1314   my_friendly_assert (!current_binding_level->class_shadowed,
1315                       19990414);
1316
1317   /* We used to use KEEP == 2 to indicate that the new block should go
1318      at the beginning of the list of blocks at this binding level,
1319      rather than the end.  This hack is no longer used.  */
1320   my_friendly_assert (keep == 0 || keep == 1, 0);
1321
1322   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
1323                       (HOST_WIDE_INT) current_binding_level->level_chain,
1324                       current_binding_level->parm_flag,
1325                       current_binding_level->keep);
1326
1327   if (current_binding_level->keep == 1)
1328     keep = 1;
1329
1330   /* Any uses of undefined labels, and any defined labels, now operate
1331      under constraints of next binding contour.  */
1332   if (cfun && !functionbody)
1333     {
1334       struct binding_level *level_chain;
1335       level_chain = current_binding_level->level_chain;
1336       if (level_chain)
1337         {
1338           struct named_label_use_list *uses;
1339           struct named_label_list *labels;
1340           for (labels = named_labels; labels; labels = labels->next)
1341             if (labels->binding_level == current_binding_level)
1342               {
1343                 tree decl;
1344                 if (current_binding_level->eh_region)
1345                   labels->eh_region = 1;
1346                 for (decl = labels->names_in_scope; decl;
1347                      decl = TREE_CHAIN (decl))
1348                   if (decl_jump_unsafe (decl))
1349                     labels->bad_decls = tree_cons (NULL_TREE, decl,
1350                                                    labels->bad_decls);
1351                 labels->binding_level = level_chain;
1352                 labels->names_in_scope = level_chain->names;
1353               }
1354
1355           for (uses = named_label_uses; uses; uses = uses->next)
1356             if (uses->binding_level == current_binding_level)
1357               {
1358                 uses->binding_level = level_chain;
1359                 uses->names_in_scope = level_chain->names;
1360               }
1361         }
1362     }
1363
1364   /* Get the decls in the order they were written.
1365      Usually current_binding_level->names is in reverse order.
1366      But parameter decls were previously put in forward order.  */
1367
1368   if (reverse)
1369     current_binding_level->names
1370       = decls = nreverse (current_binding_level->names);
1371   else
1372     decls = current_binding_level->names;
1373
1374   /* Output any nested inline functions within this block
1375      if they weren't already output.  */
1376   for (decl = decls; decl; decl = TREE_CHAIN (decl))
1377     if (TREE_CODE (decl) == FUNCTION_DECL
1378         && ! TREE_ASM_WRITTEN (decl)
1379         && DECL_INITIAL (decl) != NULL_TREE
1380         && TREE_ADDRESSABLE (decl)
1381         && decl_function_context (decl) == current_function_decl)
1382       {
1383         /* If this decl was copied from a file-scope decl
1384            on account of a block-scope extern decl,
1385            propagate TREE_ADDRESSABLE to the file-scope decl.  */
1386         if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1387           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1388         else
1389           {
1390             push_function_context ();
1391             output_inline_function (decl);
1392             pop_function_context ();
1393           }
1394       }
1395
1396   /* When not in function-at-a-time mode, expand_end_bindings will
1397      warn about unused variables.  But, in function-at-a-time mode
1398      expand_end_bindings is not passed the list of variables in the
1399      current scope, and therefore no warning is emitted.  So, we
1400      explicitly warn here.  */
1401   if (!processing_template_decl)
1402     warn_about_unused_variables (getdecls ());
1403
1404   /* If there were any declarations or structure tags in that level,
1405      or if this level is a function body,
1406      create a BLOCK to record them for the life of this function.  */
1407   block = NULL_TREE;
1408   block_previously_created = (current_binding_level->this_block != NULL_TREE);
1409   if (block_previously_created)
1410     block = current_binding_level->this_block;
1411   else if (keep == 1 || functionbody)
1412     block = make_node (BLOCK);
1413   if (block != NULL_TREE)
1414     {
1415       if (block_previously_created)
1416         {
1417           if (decls || tags || subblocks)
1418             {
1419               if (BLOCK_VARS (block))
1420                 warning ("internal compiler error: debugging info corrupted");
1421
1422               BLOCK_VARS (block) = decls;
1423
1424               /* We can have previous subblocks and new subblocks when
1425                  doing fixup_gotos with complex cleanups.  We chain the new
1426                  subblocks onto the end of any pre-existing subblocks.  */
1427               BLOCK_SUBBLOCKS (block) = chainon (BLOCK_SUBBLOCKS (block),
1428                                                  subblocks);
1429             }
1430         }
1431       else
1432         {
1433           BLOCK_VARS (block) = decls;
1434           BLOCK_SUBBLOCKS (block) = subblocks;
1435         }
1436     }
1437
1438   /* In each subblock, record that this is its superior.  */
1439   if (keep >= 0)
1440     for (link = subblocks; link; link = TREE_CHAIN (link))
1441       BLOCK_SUPERCONTEXT (link) = block;
1442
1443   /* We still support the old for-scope rules, whereby the variables
1444      in a for-init statement were in scope after the for-statement
1445      ended.  We only use the new rules in flag_new_for_scope is
1446      nonzero.  */
1447   leaving_for_scope
1448     = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1449
1450   /* Remove declarations for all the DECLs in this level.  */
1451   for (link = decls; link; link = TREE_CHAIN (link))
1452     {
1453       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
1454           && DECL_NAME (link))
1455         {
1456           tree outer_binding
1457             = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1458           tree ns_binding;
1459
1460           if (!outer_binding)
1461             ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1462           else
1463             ns_binding = NULL_TREE;
1464
1465           if (outer_binding
1466               && (BINDING_LEVEL (outer_binding)
1467                   == current_binding_level->level_chain))
1468             /* We have something like:
1469
1470                  int i;
1471                  for (int i; ;);
1472
1473                and we are leaving the `for' scope.  There's no reason to
1474                keep the binding of the inner `i' in this case.  */
1475             pop_binding (DECL_NAME (link), link);
1476           else if ((outer_binding
1477                     && (TREE_CODE (BINDING_VALUE (outer_binding))
1478                         == TYPE_DECL))
1479                    || (ns_binding
1480                        && TREE_CODE (ns_binding) == TYPE_DECL))
1481             /* Here, we have something like:
1482
1483                  typedef int I;
1484
1485                  void f () {
1486                    for (int I; ;);
1487                  }
1488
1489                We must pop the for-scope binding so we know what's a
1490                type and what isn't.  */
1491             pop_binding (DECL_NAME (link), link);
1492           else
1493             {
1494               /* Mark this VAR_DECL as dead so that we can tell we left it
1495                  there only for backward compatibility.  */
1496               DECL_DEAD_FOR_LOCAL (link) = 1;
1497
1498               /* Keep track of what should of have happenned when we
1499                  popped the binding.  */
1500               if (outer_binding && BINDING_VALUE (outer_binding))
1501                 DECL_SHADOWED_FOR_VAR (link)
1502                   = BINDING_VALUE (outer_binding);
1503
1504               /* Add it to the list of dead variables in the next
1505                  outermost binding to that we can remove these when we
1506                  leave that binding.  */
1507               current_binding_level->level_chain->dead_vars_from_for
1508                 = tree_cons (NULL_TREE, link,
1509                              current_binding_level->level_chain->
1510                              dead_vars_from_for);
1511
1512               /* Although we don't pop the CPLUS_BINDING, we do clear
1513                  its BINDING_LEVEL since the level is going away now.  */
1514               BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1515                 = 0;
1516             }
1517         }
1518       else
1519         {
1520           /* Remove the binding.  */
1521           decl = link;
1522           if (TREE_CODE (decl) == TREE_LIST)
1523             decl = TREE_VALUE (decl);
1524           if (DECL_P (decl))
1525             pop_binding (DECL_NAME (decl), decl);
1526           else if (TREE_CODE (decl) == OVERLOAD)
1527             pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1528           else
1529             my_friendly_abort (0);
1530         }
1531     }
1532
1533   /* Remove declarations for any `for' variables from inner scopes
1534      that we kept around.  */
1535   for (link = current_binding_level->dead_vars_from_for;
1536        link; link = TREE_CHAIN (link))
1537     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1538
1539   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
1540   for (link = current_binding_level->type_shadowed;
1541        link; link = TREE_CHAIN (link))
1542     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1543
1544   /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
1545   for (link = current_binding_level->shadowed_labels;
1546        link;
1547        link = TREE_CHAIN (link))
1548     pop_label (TREE_VALUE (link), TREE_PURPOSE (link));
1549
1550   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1551      list if a `using' declaration put them there.  The debugging
1552      back-ends won't understand OVERLOAD, so we remove them here.
1553      Because the BLOCK_VARS are (temporarily) shared with
1554      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1555      popped all the bindings.  */
1556   if (block)
1557     {
1558       tree* d;
1559
1560       for (d = &BLOCK_VARS (block); *d; )
1561         {
1562           if (TREE_CODE (*d) == TREE_LIST)
1563             *d = TREE_CHAIN (*d);
1564           else
1565             d = &TREE_CHAIN (*d);
1566         }
1567     }
1568
1569   /* If the level being exited is the top level of a function,
1570      check over all the labels.  */
1571   if (functionbody)
1572     {
1573       /* Since this is the top level block of a function, the vars are
1574          the function's parameters.  Don't leave them in the BLOCK
1575          because they are found in the FUNCTION_DECL instead.  */
1576       BLOCK_VARS (block) = 0;
1577       pop_labels (block);
1578     }
1579
1580   tmp = current_binding_level->keep;
1581
1582   pop_binding_level ();
1583   if (functionbody)
1584     DECL_INITIAL (current_function_decl) = block;
1585   else if (block)
1586     {
1587       if (!block_previously_created)
1588         current_binding_level->blocks
1589           = chainon (current_binding_level->blocks, block);
1590     }
1591   /* If we did not make a block for the level just exited,
1592      any blocks made for inner levels
1593      (since they cannot be recorded as subblocks in that level)
1594      must be carried forward so they will later become subblocks
1595      of something else.  */
1596   else if (subblocks)
1597     current_binding_level->blocks
1598       = chainon (current_binding_level->blocks, subblocks);
1599
1600   /* Each and every BLOCK node created here in `poplevel' is important
1601      (e.g. for proper debugging information) so if we created one
1602      earlier, mark it as "used".  */
1603   if (block)
1604     TREE_USED (block) = 1;
1605
1606   /* Take care of compiler's internal binding structures.  */
1607   if (tmp == 2)
1608     {
1609       tree scope_stmts;
1610
1611       scope_stmts
1612         = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1613       if (block)
1614         {
1615           SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1616           SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1617         }
1618
1619       block = poplevel (keep, reverse, functionbody);
1620     }
1621
1622   return block;
1623 }
1624
1625 /* Delete the node BLOCK from the current binding level.
1626    This is used for the block inside a stmt expr ({...})
1627    so that the block can be reinserted where appropriate.  */
1628
1629 void
1630 delete_block (block)
1631      tree block;
1632 {
1633   tree t;
1634   if (current_binding_level->blocks == block)
1635     current_binding_level->blocks = TREE_CHAIN (block);
1636   for (t = current_binding_level->blocks; t;)
1637     {
1638       if (TREE_CHAIN (t) == block)
1639         TREE_CHAIN (t) = TREE_CHAIN (block);
1640       else
1641         t = TREE_CHAIN (t);
1642     }
1643   TREE_CHAIN (block) = NULL_TREE;
1644   /* Clear TREE_USED which is always set by poplevel.
1645      The flag is set again if insert_block is called.  */
1646   TREE_USED (block) = 0;
1647 }
1648
1649 /* Insert BLOCK at the end of the list of subblocks of the
1650    current binding level.  This is used when a BIND_EXPR is expanded,
1651    to handle the BLOCK node inside the BIND_EXPR.  */
1652
1653 void
1654 insert_block (block)
1655      tree block;
1656 {
1657   TREE_USED (block) = 1;
1658   current_binding_level->blocks
1659     = chainon (current_binding_level->blocks, block);
1660 }
1661
1662 /* Set the BLOCK node for the innermost scope
1663    (the one we are currently in).  */
1664
1665 void
1666 set_block (block)
1667     register tree block;
1668 {
1669   current_binding_level->this_block = block;
1670 }
1671
1672 /* Do a pushlevel for class declarations.  */
1673
1674 void
1675 pushlevel_class ()
1676 {
1677   register struct binding_level *newlevel;
1678
1679   /* Reuse or create a struct for this binding level.  */
1680 #if defined(DEBUG_CP_BINDING_LEVELS)
1681   if (0)
1682 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1683   if (free_binding_level)
1684 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1685     {
1686       newlevel = free_binding_level;
1687       free_binding_level = free_binding_level->level_chain;
1688     }
1689   else
1690     newlevel = make_binding_level ();
1691
1692 #if defined(DEBUG_CP_BINDING_LEVELS)
1693   is_class_level = 1;
1694 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1695
1696   push_binding_level (newlevel, 0, 0);
1697
1698   class_binding_level = current_binding_level;
1699   class_binding_level->parm_flag = 2;
1700   class_binding_level->this_class = current_class_type;
1701 }
1702
1703 /* ...and a poplevel for class declarations.  */
1704
1705 void
1706 poplevel_class ()
1707 {
1708   register struct binding_level *level = class_binding_level;
1709   tree shadowed;
1710
1711   my_friendly_assert (level != 0, 354);
1712
1713   /* If we're leaving a toplevel class, don't bother to do the setting
1714      of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1715      shouldn't even be used when current_class_type isn't set, and second,
1716      if we don't touch it here, we're able to use the cache effect if the
1717      next time we're entering a class scope, it is the same class.  */
1718   if (current_class_depth != 1)
1719     {
1720       struct binding_level* b;
1721
1722       /* Clear out our IDENTIFIER_CLASS_VALUEs.  */
1723       for (shadowed = level->class_shadowed;
1724            shadowed;
1725            shadowed = TREE_CHAIN (shadowed))
1726         IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1727
1728       /* Find the next enclosing class, and recreate
1729          IDENTIFIER_CLASS_VALUEs appropriate for that class.  */
1730       b = level->level_chain;
1731       while (b && b->parm_flag != 2)
1732         b = b->level_chain;
1733
1734       if (b)
1735         for (shadowed = b->class_shadowed;
1736              shadowed;
1737              shadowed = TREE_CHAIN (shadowed))
1738           {
1739             tree t;
1740
1741             t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1742             while (t && BINDING_LEVEL (t) != b)
1743               t = TREE_CHAIN (t);
1744
1745             if (t)
1746               IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1747                 = BINDING_VALUE (t);
1748           }
1749     }
1750   else
1751     /* Remember to save what IDENTIFIER's were bound in this scope so we
1752        can recover from cache misses.  */
1753     {
1754       previous_class_type = current_class_type;
1755       previous_class_values = class_binding_level->class_shadowed;
1756     }
1757   for (shadowed = level->type_shadowed;
1758        shadowed;
1759        shadowed = TREE_CHAIN (shadowed))
1760     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1761
1762   /* Remove the bindings for all of the class-level declarations.  */
1763   for (shadowed = level->class_shadowed;
1764        shadowed;
1765        shadowed = TREE_CHAIN (shadowed))
1766     pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1767
1768   GNU_xref_end_scope ((HOST_WIDE_INT) class_binding_level,
1769                       (HOST_WIDE_INT) class_binding_level->level_chain,
1770                       class_binding_level->parm_flag,
1771                       class_binding_level->keep);
1772
1773   /* Now, pop out of the binding level which we created up in the
1774      `pushlevel_class' routine.  */
1775 #if defined(DEBUG_CP_BINDING_LEVELS)
1776   is_class_level = 1;
1777 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1778
1779   pop_binding_level ();
1780 }
1781
1782 /* We are entering the scope of a class.  Clear IDENTIFIER_CLASS_VALUE
1783    for any names in enclosing classes.  */
1784
1785 void
1786 clear_identifier_class_values ()
1787 {
1788   tree t;
1789
1790   if (!class_binding_level)
1791     return;
1792
1793   for (t = class_binding_level->class_shadowed;
1794        t;
1795        t = TREE_CHAIN (t))
1796     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1797 }
1798
1799 /* Returns non-zero if T is a virtual function table.  */
1800
1801 int
1802 vtable_decl_p (t, data)
1803      tree t;
1804      void *data ATTRIBUTE_UNUSED;
1805 {
1806   return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1807 }
1808
1809 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1810    functions.  */
1811
1812 int
1813 vtype_decl_p (t, data)
1814      tree t;
1815      void *data ATTRIBUTE_UNUSED;
1816 {
1817   return (TREE_CODE (t) == TYPE_DECL
1818           && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE
1819           && TYPE_POLYMORPHIC_P (TREE_TYPE (t)));
1820 }
1821
1822 /* Return the declarations that are members of the namespace NS.  */
1823
1824 tree
1825 cp_namespace_decls (ns)
1826      tree ns;
1827 {
1828   return NAMESPACE_LEVEL (ns)->names;
1829 }
1830
1831 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1832    itself, calling F for each.  The DATA is passed to F as well.  */
1833
1834 static int
1835 walk_namespaces_r (namespace, f, data)
1836      tree namespace;
1837      walk_namespaces_fn f;
1838      void *data;
1839 {
1840   tree current;
1841   int result = 0;
1842
1843   result |= (*f) (namespace, data);
1844
1845   for (current = cp_namespace_decls (namespace);
1846        current;
1847        current = TREE_CHAIN (current))
1848     {
1849       if (TREE_CODE (current) != NAMESPACE_DECL
1850           || DECL_NAMESPACE_ALIAS (current))
1851         continue;
1852       if (!DECL_LANG_SPECIFIC (current))
1853         {
1854           /* Hmm. std. */
1855           my_friendly_assert (current == std_node, 393);
1856           continue;
1857         }
1858
1859       /* We found a namespace.  */
1860       result |= walk_namespaces_r (current, f, data);
1861     }
1862
1863   return result;
1864 }
1865
1866 /* Walk all the namespaces, calling F for each.  The DATA is passed to
1867    F as well.  */
1868
1869 int
1870 walk_namespaces (f, data)
1871      walk_namespaces_fn f;
1872      void *data;
1873 {
1874   return walk_namespaces_r (global_namespace, f, data);
1875 }
1876
1877 struct walk_globals_data {
1878   walk_globals_pred p;
1879   walk_globals_fn f;
1880   void *data;
1881 };
1882
1883 /* Walk the global declarations in NAMESPACE.  Whenever one is found
1884    for which P returns non-zero, call F with its address.  If any call
1885    to F returns a non-zero value, return a non-zero value.  */
1886
1887 static int
1888 walk_globals_r (namespace, data)
1889      tree namespace;
1890      void *data;
1891 {
1892   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1893   walk_globals_pred p = wgd->p;
1894   walk_globals_fn f = wgd->f;
1895   void *d = wgd->data;
1896   tree *t;
1897   int result = 0;
1898
1899   t = &NAMESPACE_LEVEL (namespace)->names;
1900
1901   while (*t)
1902     {
1903       tree glbl = *t;
1904
1905       if ((*p) (glbl, d))
1906         result |= (*f) (t, d);
1907
1908       /* If F changed *T, then *T still points at the next item to
1909          examine.  */
1910       if (*t == glbl)
1911         t = &TREE_CHAIN (*t);
1912     }
1913
1914   return result;
1915 }
1916
1917 /* Walk the global declarations.  Whenever one is found for which P
1918    returns non-zero, call F with its address.  If any call to F
1919    returns a non-zero value, return a non-zero value.  */
1920
1921 int
1922 walk_globals (p, f, data)
1923      walk_globals_pred p;
1924      walk_globals_fn f;
1925      void *data;
1926 {
1927   struct walk_globals_data wgd;
1928   wgd.p = p;
1929   wgd.f = f;
1930   wgd.data = data;
1931
1932   return walk_namespaces (walk_globals_r, &wgd);
1933 }
1934
1935 /* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
1936    DATA is non-NULL, this is the last time we will call
1937    wrapup_global_declarations for this NAMESPACE.  */
1938
1939 int
1940 wrapup_globals_for_namespace (namespace, data)
1941      tree namespace;
1942      void *data;
1943 {
1944   tree globals = cp_namespace_decls (namespace);
1945   int len = list_length (globals);
1946   tree *vec = (tree *) alloca (sizeof (tree) * len);
1947   int i;
1948   int result;
1949   tree decl;
1950   int last_time = (data != 0);
1951
1952   if (last_time && namespace == global_namespace)
1953     /* Let compile_file handle the global namespace.  */
1954     return 0;
1955
1956   /* Process the decls in reverse order--earliest first.
1957      Put them into VEC from back to front, then take out from front.  */
1958
1959   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1960     {
1961       /* Pretend we've output an unused static variable.  This ensures
1962          that the toplevel __FUNCTION__ etc won't be emitted, unless
1963          needed. */
1964       if (TREE_CODE (decl) == VAR_DECL && DECL_ARTIFICIAL (decl)
1965           && !TREE_PUBLIC (decl) && !TREE_USED (decl))
1966         {
1967           TREE_ASM_WRITTEN (decl) = 1;
1968           DECL_IGNORED_P (decl) = 1;
1969         }
1970       vec[len - i - 1] = decl;
1971     }
1972
1973   if (last_time)
1974     {
1975       check_global_declarations (vec, len);
1976       return 0;
1977     }
1978
1979   /* Temporarily mark vtables as external.  That prevents
1980      wrapup_global_declarations from writing them out; we must process
1981      them ourselves in finish_vtable_vardecl.  */
1982   for (i = 0; i < len; ++i)
1983     if (vtable_decl_p (vec[i], /*data=*/0) && !DECL_EXTERNAL (vec[i]))
1984       {
1985         DECL_NOT_REALLY_EXTERN (vec[i]) = 1;
1986         DECL_EXTERNAL (vec[i]) = 1;
1987       }
1988
1989   /* Write out any globals that need to be output.  */
1990   result = wrapup_global_declarations (vec, len);
1991
1992   /* Undo the hack to DECL_EXTERNAL above.  */
1993   for (i = 0; i < len; ++i)
1994     if (vtable_decl_p (vec[i], /*data=*/0)
1995         && DECL_NOT_REALLY_EXTERN (vec[i]))
1996       {
1997         DECL_NOT_REALLY_EXTERN (vec[i]) = 0;
1998         DECL_EXTERNAL (vec[i]) = 0;
1999       }
2000
2001   return result;
2002 }
2003
2004 \f
2005 /* Mark ARG (which is really a struct binding_level **) for GC.  */
2006
2007 static void
2008 mark_binding_level (arg)
2009      void *arg;
2010 {
2011   struct binding_level *lvl = *(struct binding_level **)arg;
2012
2013   for (; lvl; lvl = lvl->level_chain)
2014     {
2015       ggc_mark_tree (lvl->names);
2016       ggc_mark_tree (lvl->tags);
2017       ggc_mark_tree (lvl->usings);
2018       ggc_mark_tree (lvl->using_directives);
2019       ggc_mark_tree (lvl->class_shadowed);
2020       ggc_mark_tree (lvl->type_shadowed);
2021       ggc_mark_tree (lvl->shadowed_labels);
2022       ggc_mark_tree (lvl->blocks);
2023       ggc_mark_tree (lvl->this_block);
2024       ggc_mark_tree (lvl->this_class);
2025       ggc_mark_tree (lvl->incomplete);
2026       ggc_mark_tree (lvl->dead_vars_from_for);
2027     }
2028 }
2029
2030 static void
2031 mark_named_label_lists (labs, uses)
2032      void *labs;
2033      void *uses;
2034 {
2035   struct named_label_list *l = *(struct named_label_list **)labs;
2036   struct named_label_use_list *u = *(struct named_label_use_list **)uses;
2037
2038   for (; l; l = l->next)
2039     {
2040       ggc_mark (l);
2041       mark_binding_level (l->binding_level);
2042       ggc_mark_tree (l->old_value);
2043       ggc_mark_tree (l->label_decl);
2044       ggc_mark_tree (l->bad_decls);
2045     }
2046
2047   for (; u; u = u->next)
2048     ggc_mark (u);
2049 }
2050 \f
2051 /* For debugging.  */
2052 static int no_print_functions = 0;
2053 static int no_print_builtins = 0;
2054
2055 void
2056 print_binding_level (lvl)
2057      struct binding_level *lvl;
2058 {
2059   tree t;
2060   int i = 0, len;
2061   fprintf (stderr, " blocks=");
2062   fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
2063   fprintf (stderr, " n_incomplete=%d parm_flag=%d keep=%d",
2064            list_length (lvl->incomplete), lvl->parm_flag, lvl->keep);
2065   if (lvl->tag_transparent)
2066     fprintf (stderr, " tag-transparent");
2067   if (lvl->more_cleanups_ok)
2068     fprintf (stderr, " more-cleanups-ok");
2069   if (lvl->have_cleanups)
2070     fprintf (stderr, " have-cleanups");
2071   fprintf (stderr, "\n");
2072   if (lvl->names)
2073     {
2074       fprintf (stderr, " names:\t");
2075       /* We can probably fit 3 names to a line?  */
2076       for (t = lvl->names; t; t = TREE_CHAIN (t))
2077         {
2078           if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
2079             continue;
2080           if (no_print_builtins
2081               && (TREE_CODE (t) == TYPE_DECL)
2082               && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
2083             continue;
2084
2085           /* Function decls tend to have longer names.  */
2086           if (TREE_CODE (t) == FUNCTION_DECL)
2087             len = 3;
2088           else
2089             len = 2;
2090           i += len;
2091           if (i > 6)
2092             {
2093               fprintf (stderr, "\n\t");
2094               i = len;
2095             }
2096           print_node_brief (stderr, "", t, 0);
2097           if (t == error_mark_node)
2098             break;
2099         }
2100       if (i)
2101         fprintf (stderr, "\n");
2102     }
2103   if (lvl->tags)
2104     {
2105       fprintf (stderr, " tags:\t");
2106       i = 0;
2107       for (t = lvl->tags; t; t = TREE_CHAIN (t))
2108         {
2109           if (TREE_PURPOSE (t) == NULL_TREE)
2110             len = 3;
2111           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2112             len = 2;
2113           else
2114             len = 4;
2115           i += len;
2116           if (i > 5)
2117             {
2118               fprintf (stderr, "\n\t");
2119               i = len;
2120             }
2121           if (TREE_PURPOSE (t) == NULL_TREE)
2122             {
2123               print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
2124               fprintf (stderr, ">");
2125             }
2126           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2127             print_node_brief (stderr, "", TREE_VALUE (t), 0);
2128           else
2129             {
2130               print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
2131               print_node_brief (stderr, "", TREE_VALUE (t), 0);
2132               fprintf (stderr, ">");
2133             }
2134         }
2135       if (i)
2136         fprintf (stderr, "\n");
2137     }
2138   if (lvl->class_shadowed)
2139     {
2140       fprintf (stderr, " class-shadowed:");
2141       for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
2142         {
2143           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2144         }
2145       fprintf (stderr, "\n");
2146     }
2147   if (lvl->type_shadowed)
2148     {
2149       fprintf (stderr, " type-shadowed:");
2150       for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
2151         {
2152           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2153         }
2154       fprintf (stderr, "\n");
2155     }
2156 }
2157
2158 void
2159 print_other_binding_stack (stack)
2160      struct binding_level *stack;
2161 {
2162   struct binding_level *level;
2163   for (level = stack; level != global_binding_level; level = level->level_chain)
2164     {
2165       fprintf (stderr, "binding level ");
2166       fprintf (stderr, HOST_PTR_PRINTF, level);
2167       fprintf (stderr, "\n");
2168       print_binding_level (level);
2169     }
2170 }
2171
2172 void
2173 print_binding_stack ()
2174 {
2175   struct binding_level *b;
2176   fprintf (stderr, "current_binding_level=");
2177   fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
2178   fprintf (stderr, "\nclass_binding_level=");
2179   fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
2180   fprintf (stderr, "\nglobal_binding_level=");
2181   fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
2182   fprintf (stderr, "\n");
2183   if (class_binding_level)
2184     {
2185       for (b = class_binding_level; b; b = b->level_chain)
2186         if (b == current_binding_level)
2187           break;
2188       if (b)
2189         b = class_binding_level;
2190       else
2191         b = current_binding_level;
2192     }
2193   else
2194     b = current_binding_level;
2195   print_other_binding_stack (b);
2196   fprintf (stderr, "global:\n");
2197   print_binding_level (global_binding_level);
2198 }
2199
2200 /* Namespace binding access routines: The namespace_bindings field of
2201    the identifier is polymorphic, with three possible values:
2202    NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2203    indicating the BINDING_VALUE of global_namespace. */
2204
2205 /* Check whether the a binding for the name to scope is known.
2206    Assumes that the bindings of the name are already a list
2207    of bindings. Returns the binding found, or NULL_TREE. */
2208
2209 static tree
2210 find_binding (name, scope)
2211      tree name;
2212      tree scope;
2213 {
2214   tree iter, prev = NULL_TREE;
2215
2216   scope = ORIGINAL_NAMESPACE (scope);
2217
2218   for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2219        iter = TREE_CHAIN (iter))
2220     {
2221       my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2222       if (BINDING_SCOPE (iter) == scope)
2223         {
2224           /* Move binding found to the front of the list, so
2225              subsequent lookups will find it faster. */
2226           if (prev)
2227             {
2228               TREE_CHAIN (prev) = TREE_CHAIN (iter);
2229               TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2230               IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2231             }
2232           return iter;
2233         }
2234       prev = iter;
2235     }
2236   return NULL_TREE;
2237 }
2238
2239 /* Always returns a binding for name in scope. If the
2240    namespace_bindings is not a list, convert it to one first.
2241    If no binding is found, make a new one. */
2242
2243 tree
2244 binding_for_name (name, scope)
2245      tree name;
2246      tree scope;
2247 {
2248   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2249   tree result;
2250
2251   scope = ORIGINAL_NAMESPACE (scope);
2252
2253   if (b && TREE_CODE (b) != CPLUS_BINDING)
2254     {
2255       /* Get rid of optimization for global scope. */
2256       IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2257       BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2258       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2259     }
2260   if (b && (result = find_binding (name, scope)))
2261     return result;
2262   /* Not found, make a new one. */
2263   result = make_node (CPLUS_BINDING);
2264   TREE_CHAIN (result) = b;
2265   IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2266   BINDING_SCOPE (result) = scope;
2267   BINDING_TYPE (result) = NULL_TREE;
2268   BINDING_VALUE (result) = NULL_TREE;
2269   return result;
2270 }
2271
2272 /* Return the binding value for name in scope, considering that
2273    namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2274
2275 tree
2276 namespace_binding (name, scope)
2277      tree name;
2278      tree scope;
2279 {
2280   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2281   if (b == NULL_TREE)
2282     return NULL_TREE;
2283   if (scope == NULL_TREE)
2284     scope = global_namespace;
2285   if (TREE_CODE (b) != CPLUS_BINDING)
2286     return (scope == global_namespace) ? b : NULL_TREE;
2287   name = find_binding (name,scope);
2288   if (name == NULL_TREE)
2289     return name;
2290   return BINDING_VALUE (name);
2291 }
2292
2293 /* Set the binding value for name in scope. If modifying the binding
2294    of global_namespace is attempted, try to optimize it. */
2295
2296 void
2297 set_namespace_binding (name, scope, val)
2298      tree name;
2299      tree scope;
2300      tree val;
2301 {
2302   tree b;
2303
2304   if (scope == NULL_TREE)
2305     scope = global_namespace;
2306
2307   if (scope == global_namespace)
2308     {
2309       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2310       if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2311         {
2312           IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2313           return;
2314         }
2315     }
2316   b = binding_for_name (name, scope);
2317   BINDING_VALUE (b) = val;
2318 }
2319
2320 /* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
2321    select a name that is unique to this compilation unit.  */
2322
2323 void
2324 push_namespace (name)
2325      tree name;
2326 {
2327   tree d = NULL_TREE;
2328   int need_new = 1;
2329   int implicit_use = 0;
2330   int global = 0;
2331   if (!global_namespace)
2332     {
2333       /* This must be ::. */
2334       my_friendly_assert (name == get_identifier ("::"), 377);
2335       global = 1;
2336     }
2337   else if (!name)
2338     {
2339       /* The name of anonymous namespace is unique for the translation
2340          unit.  */
2341       if (!anonymous_namespace_name)
2342         anonymous_namespace_name = get_file_function_name ('N');
2343       name = anonymous_namespace_name;
2344       d = IDENTIFIER_NAMESPACE_VALUE (name);
2345       if (d)
2346         /* Reopening anonymous namespace.  */
2347         need_new = 0;
2348       implicit_use = 1;
2349     }
2350   else if (current_namespace == global_namespace
2351            && name == DECL_NAME (std_node))
2352     {
2353       in_std++;
2354       return;
2355     }
2356   else
2357     {
2358       /* Check whether this is an extended namespace definition. */
2359       d = IDENTIFIER_NAMESPACE_VALUE (name);
2360       if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2361         {
2362           need_new = 0;
2363           if (DECL_NAMESPACE_ALIAS (d))
2364             {
2365               cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
2366                         d, DECL_NAMESPACE_ALIAS (d));
2367               d = DECL_NAMESPACE_ALIAS (d);
2368             }
2369         }
2370     }
2371
2372   if (need_new)
2373     {
2374       /* Make a new namespace, binding the name to it. */
2375       d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2376       /* The global namespace is not pushed, and the global binding
2377          level is set elsewhere.  */
2378       if (!global)
2379         {
2380           DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
2381           d = pushdecl (d);
2382           pushlevel (0);
2383           declare_namespace_level ();
2384           NAMESPACE_LEVEL (d) = current_binding_level;
2385         }
2386     }
2387   else
2388     resume_binding_level (NAMESPACE_LEVEL (d));
2389
2390   if (implicit_use)
2391     do_using_directive (d);
2392   /* Enter the name space. */
2393   current_namespace = d;
2394 }
2395
2396 /* Pop from the scope of the current namespace.  */
2397
2398 void
2399 pop_namespace ()
2400 {
2401   if (current_namespace == global_namespace)
2402     {
2403       my_friendly_assert (in_std>0, 980421);
2404       in_std--;
2405       return;
2406     }
2407   current_namespace = CP_DECL_CONTEXT (current_namespace);
2408   /* The binding level is not popped, as it might be re-opened later.  */
2409   suspend_binding_level ();
2410 }
2411
2412 /* Push into the scope of the namespace NS, even if it is deeply
2413    nested within another namespace.  */
2414
2415 void
2416 push_nested_namespace (ns)
2417      tree ns;
2418 {
2419   if (ns == global_namespace)
2420     push_to_top_level ();
2421   else
2422     {
2423       push_nested_namespace (CP_DECL_CONTEXT (ns));
2424       push_namespace (DECL_NAME (ns));
2425     }
2426 }
2427
2428 /* Pop back from the scope of the namespace NS, which was previously
2429    entered with push_nested_namespace.  */
2430
2431 void
2432 pop_nested_namespace (ns)
2433      tree ns;
2434 {
2435   while (ns != global_namespace)
2436     {
2437       pop_namespace ();
2438       ns = CP_DECL_CONTEXT (ns);
2439     }
2440
2441   pop_from_top_level ();
2442 }
2443
2444 \f
2445 /* Subroutines for reverting temporarily to top-level for instantiation
2446    of templates and such.  We actually need to clear out the class- and
2447    local-value slots of all identifiers, so that only the global values
2448    are at all visible.  Simply setting current_binding_level to the global
2449    scope isn't enough, because more binding levels may be pushed.  */
2450 struct saved_scope *scope_chain;
2451
2452 /* Mark ST for GC.  */
2453
2454 static void
2455 mark_stmt_tree (st)
2456      stmt_tree st;
2457 {
2458   ggc_mark_tree (st->x_last_stmt);
2459   ggc_mark_tree (st->x_last_expr_type);
2460 }
2461
2462 /* Mark ARG (which is really a struct saved_scope **) for GC.  */
2463
2464 static void
2465 mark_saved_scope (arg)
2466      void *arg;
2467 {
2468   struct saved_scope *t = *(struct saved_scope **)arg;
2469   while (t)
2470     {
2471       mark_binding_level (&t->class_bindings);
2472       ggc_mark_tree (t->old_bindings);
2473       ggc_mark_tree (t->old_namespace);
2474       ggc_mark_tree (t->class_name);
2475       ggc_mark_tree (t->class_type);
2476       ggc_mark_tree (t->access_specifier);
2477       ggc_mark_tree (t->function_decl);
2478       if (t->lang_base)
2479         ggc_mark_tree_varray (t->lang_base);
2480       ggc_mark_tree (t->lang_name);
2481       ggc_mark_tree (t->x_function_parms);
2482       ggc_mark_tree (t->template_parms);
2483       ggc_mark_tree (t->x_previous_class_type);
2484       ggc_mark_tree (t->x_previous_class_values);
2485       ggc_mark_tree (t->x_saved_tree);
2486       ggc_mark_tree (t->incomplete);
2487       ggc_mark_tree (t->lookups);
2488
2489       mark_stmt_tree (&t->x_stmt_tree);
2490       mark_binding_level (&t->bindings);
2491       t = t->prev;
2492     }
2493 }
2494
2495 static tree
2496 store_bindings (names, old_bindings)
2497      tree names, old_bindings;
2498 {
2499   tree t;
2500   for (t = names; t; t = TREE_CHAIN (t))
2501     {
2502       tree binding, t1, id;
2503
2504       if (TREE_CODE (t) == TREE_LIST)
2505         id = TREE_PURPOSE (t);
2506       else
2507         id = DECL_NAME (t);
2508
2509       if (!id
2510           /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2511              we have no IDENTIFIER_BINDING if we have left the class
2512              scope, but cached the class-level declarations.  */
2513           || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2514         continue;
2515
2516       for (t1 = old_bindings; t1; t1 = TREE_CHAIN (t1))
2517         if (TREE_VEC_ELT (t1, 0) == id)
2518           goto skip_it;
2519
2520       binding = make_tree_vec (4);
2521
2522       if (id)
2523         {
2524           my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2525           TREE_VEC_ELT (binding, 0) = id;
2526           TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2527           TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2528           TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2529           IDENTIFIER_BINDING (id) = NULL_TREE;
2530           IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2531         }
2532       TREE_CHAIN (binding) = old_bindings;
2533       old_bindings = binding;
2534     skip_it:
2535       ;
2536     }
2537   return old_bindings;
2538 }
2539
2540 void
2541 maybe_push_to_top_level (pseudo)
2542      int pseudo;
2543 {
2544   struct saved_scope *s;
2545   struct binding_level *b;
2546   tree old_bindings;
2547   int need_pop;
2548
2549   s = (struct saved_scope *) xcalloc (1, sizeof (struct saved_scope));
2550
2551   b = scope_chain ? current_binding_level : 0;
2552
2553   /* If we're in the middle of some function, save our state.  */
2554   if (cfun)
2555     {
2556       need_pop = 1;
2557       push_function_context_to (NULL_TREE);
2558     }
2559   else
2560     need_pop = 0;
2561
2562   old_bindings = NULL_TREE;
2563   if (scope_chain && previous_class_type)
2564     old_bindings = store_bindings (previous_class_values, old_bindings);
2565
2566   /* Have to include global_binding_level, because class-level decls
2567      aren't listed anywhere useful.  */
2568   for (; b; b = b->level_chain)
2569     {
2570       tree t;
2571
2572       /* Template IDs are inserted into the global level. If they were
2573          inserted into namespace level, finish_file wouldn't find them
2574          when doing pending instantiations. Therefore, don't stop at
2575          namespace level, but continue until :: .  */
2576       if (b == global_binding_level || (pseudo && b->template_parms_p))
2577         break;
2578
2579       old_bindings = store_bindings (b->names, old_bindings);
2580       /* We also need to check class_shadowed to save class-level type
2581          bindings, since pushclass doesn't fill in b->names.  */
2582       if (b->parm_flag == 2)
2583         old_bindings = store_bindings (b->class_shadowed, old_bindings);
2584
2585       /* Unwind type-value slots back to top level.  */
2586       for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2587         SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2588     }
2589   s->prev = scope_chain;
2590   s->old_bindings = old_bindings;
2591   s->bindings = b;
2592   s->need_pop_function_context = need_pop;
2593   s->function_decl = current_function_decl;
2594
2595   scope_chain = s;
2596   current_function_decl = NULL_TREE;
2597   VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2598   current_lang_stack = &VARRAY_TREE (current_lang_base, 0);
2599   current_lang_name = lang_name_cplusplus;
2600   current_namespace = global_namespace;
2601 }
2602
2603 void
2604 push_to_top_level ()
2605 {
2606   maybe_push_to_top_level (0);
2607 }
2608
2609 void
2610 pop_from_top_level ()
2611 {
2612   struct saved_scope *s = scope_chain;
2613   tree t;
2614
2615   /* Clear out class-level bindings cache.  */
2616   if (previous_class_type)
2617     invalidate_class_lookup_cache ();
2618
2619   VARRAY_FREE (current_lang_base);
2620
2621   scope_chain = s->prev;
2622   for (t = s->old_bindings; t; t = TREE_CHAIN (t))
2623     {
2624       tree id = TREE_VEC_ELT (t, 0);
2625       if (id)
2626         {
2627           SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2628           IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2629           IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2630         }
2631     }
2632
2633   /* If we were in the middle of compiling a function, restore our
2634      state.  */
2635   if (s->need_pop_function_context)
2636     pop_function_context_from (NULL_TREE);
2637   current_function_decl = s->function_decl;
2638
2639   free (s);
2640 }
2641 \f
2642 /* Push a definition of struct, union or enum tag "name".
2643    into binding_level "b".   "type" should be the type node,
2644    We assume that the tag "name" is not already defined.
2645
2646    Note that the definition may really be just a forward reference.
2647    In that case, the TYPE_SIZE will be a NULL_TREE.
2648
2649    C++ gratuitously puts all these tags in the name space.  */
2650
2651 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2652    record the shadowed value for this binding contour.  TYPE is
2653    the type that ID maps to.  */
2654
2655 static void
2656 set_identifier_type_value_with_scope (id, type, b)
2657      tree id;
2658      tree type;
2659      struct binding_level *b;
2660 {
2661   if (!b->namespace_p)
2662     {
2663       /* Shadow the marker, not the real thing, so that the marker
2664          gets restored later. */
2665       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2666       b->type_shadowed
2667         = tree_cons (id, old_type_value, b->type_shadowed);
2668     }
2669   else
2670     {
2671       tree binding = binding_for_name (id, current_namespace);
2672       BINDING_TYPE (binding) = type;
2673       /* Store marker instead of real type. */
2674       type = global_type_node;
2675     }
2676   SET_IDENTIFIER_TYPE_VALUE (id, type);
2677 }
2678
2679 /* As set_identifier_type_value_with_scope, but using current_binding_level.  */
2680
2681 void
2682 set_identifier_type_value (id, type)
2683      tree id;
2684      tree type;
2685 {
2686   set_identifier_type_value_with_scope (id, type, current_binding_level);
2687 }
2688
2689 /* Return the type associated with id. */
2690
2691 tree
2692 identifier_type_value (id)
2693      tree id;
2694 {
2695   /* There is no type with that name, anywhere. */
2696   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2697     return NULL_TREE;
2698   /* This is not the type marker, but the real thing. */
2699   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2700     return REAL_IDENTIFIER_TYPE_VALUE (id);
2701   /* Have to search for it. It must be on the global level, now.
2702      Ask lookup_name not to return non-types. */
2703   id = lookup_name_real (id, 2, 1, 0);
2704   if (id)
2705     return TREE_TYPE (id);
2706   return NULL_TREE;
2707 }
2708
2709 /* Pop off extraneous binding levels left over due to syntax errors.
2710
2711    We don't pop past namespaces, as they might be valid.  */
2712
2713 void
2714 pop_everything ()
2715 {
2716 #ifdef DEBUG_CP_BINDING_LEVELS
2717   fprintf (stderr, "XXX entering pop_everything ()\n");
2718 #endif
2719   while (!toplevel_bindings_p ())
2720     {
2721       if (current_binding_level->parm_flag == 2)
2722         pop_nested_class ();
2723       else
2724         poplevel (0, 0, 0);
2725     }
2726 #ifdef DEBUG_CP_BINDING_LEVELS
2727   fprintf (stderr, "XXX leaving pop_everything ()\n");
2728 #endif
2729 }
2730
2731 /* The type TYPE is being declared.  If it is a class template, or a
2732    specialization of a class template, do any processing required and
2733    perform error-checking.  If IS_FRIEND is non-zero, this TYPE is
2734    being declared a friend.  B is the binding level at which this TYPE
2735    should be bound.
2736
2737    Returns the TYPE_DECL for TYPE, which may have been altered by this
2738    processing.  */
2739
2740 static tree
2741 maybe_process_template_type_declaration (type, globalize, b)
2742      tree type;
2743      int globalize;
2744      struct binding_level* b;
2745 {
2746   tree decl = TYPE_NAME (type);
2747
2748   if (processing_template_parmlist)
2749     /* You can't declare a new template type in a template parameter
2750        list.  But, you can declare a non-template type:
2751
2752          template <class A*> struct S;
2753
2754        is a forward-declaration of `A'.  */
2755     ;
2756   else
2757     {
2758       maybe_check_template_type (type);
2759
2760       my_friendly_assert (IS_AGGR_TYPE (type)
2761                           || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2762
2763
2764       if (processing_template_decl)
2765         {
2766           /* This may change after the call to
2767              push_template_decl_real, but we want the original value.  */
2768           tree name = DECL_NAME (decl);
2769
2770           decl = push_template_decl_real (decl, globalize);
2771           /* If the current binding level is the binding level for the
2772              template parameters (see the comment in
2773              begin_template_parm_list) and the enclosing level is a class
2774              scope, and we're not looking at a friend, push the
2775              declaration of the member class into the class scope.  In the
2776              friend case, push_template_decl will already have put the
2777              friend into global scope, if appropriate.  */
2778           if (TREE_CODE (type) != ENUMERAL_TYPE
2779               && !globalize && b->template_parms_p
2780               && b->level_chain->parm_flag == 2)
2781             {
2782               finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2783               /* Put this tag on the list of tags for the class, since
2784                  that won't happen below because B is not the class
2785                  binding level, but is instead the pseudo-global level.  */
2786               b->level_chain->tags =
2787                 tree_cons (name, type, b->level_chain->tags);
2788               if (!COMPLETE_TYPE_P (current_class_type))
2789                 CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2790             }
2791         }
2792     }
2793
2794   return decl;
2795 }
2796
2797 /* In C++, you don't have to write `struct S' to refer to `S'; you
2798    can just use `S'.  We accomplish this by creating a TYPE_DECL as
2799    if the user had written `typedef struct S S'.  Create and return
2800    the TYPE_DECL for TYPE.  */
2801
2802 tree
2803 create_implicit_typedef (name, type)
2804      tree name;
2805      tree type;
2806 {
2807   tree decl;
2808
2809   decl = build_decl (TYPE_DECL, name, type);
2810   DECL_ARTIFICIAL (decl) = 1;
2811   /* There are other implicit type declarations, like the one *within*
2812      a class that allows you to write `S::S'.  We must distinguish
2813      amongst these.  */
2814   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2815   TYPE_NAME (type) = decl;
2816
2817   return decl;
2818 }
2819
2820 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2821    Normally put it into the inner-most non-tag-transparent scope,
2822    but if GLOBALIZE is true, put it in the inner-most non-class scope.
2823    The latter is needed for implicit declarations.  */
2824
2825 void
2826 pushtag (name, type, globalize)
2827      tree name, type;
2828      int globalize;
2829 {
2830   register struct binding_level *b;
2831
2832   b = current_binding_level;
2833   while (b->tag_transparent
2834          || (globalize && b->parm_flag == 2))
2835     b = b->level_chain;
2836
2837   b->tags = tree_cons (name, type, b->tags);
2838
2839   if (name)
2840     {
2841       /* Do C++ gratuitous typedefing.  */
2842       if (IDENTIFIER_TYPE_VALUE (name) != type)
2843         {
2844           register tree d = NULL_TREE;
2845           int in_class = 0;
2846           tree context = TYPE_CONTEXT (type);
2847
2848           if (! context)
2849             {
2850               tree cs = current_scope ();
2851
2852               if (! globalize)
2853                 context = cs;
2854               else if (cs != NULL_TREE && TYPE_P (cs))
2855                 /* When declaring a friend class of a local class, we want
2856                    to inject the newly named class into the scope
2857                    containing the local class, not the namespace scope.  */
2858                 context = decl_function_context (get_type_decl (cs));
2859             }
2860           if (!context)
2861             context = current_namespace;
2862
2863           if ((b->template_parms_p && b->level_chain->parm_flag == 2)
2864               || b->parm_flag == 2)
2865             in_class = 1;
2866
2867           if (current_lang_name == lang_name_java)
2868             TYPE_FOR_JAVA (type) = 1;
2869
2870           d = create_implicit_typedef (name, type);
2871           DECL_CONTEXT (d) = FROB_CONTEXT (context);
2872           if (! in_class)
2873             set_identifier_type_value_with_scope (name, type, b);
2874
2875           d = maybe_process_template_type_declaration (type,
2876                                                        globalize, b);
2877
2878           if (b->parm_flag == 2)
2879             {
2880               if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2881                 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2882                    class.  But if it's a member template class, we
2883                    want the TEMPLATE_DECL, not the TYPE_DECL, so this
2884                    is done later.  */
2885                 finish_member_declaration (d);
2886               else
2887                 pushdecl_class_level (d);
2888             }
2889           else
2890             d = pushdecl_with_scope (d, b);
2891
2892           if (ANON_AGGRNAME_P (name))
2893             DECL_IGNORED_P (d) = 1;
2894
2895           TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2896           DECL_ASSEMBLER_NAME (d) = DECL_NAME (d);
2897
2898           /* If this is a local class, keep track of it.  We need this
2899              information for name-mangling, and so that it is possible to find
2900              all function definitions in a translation unit in a convenient
2901              way.  (It's otherwise tricky to find a member function definition
2902              it's only pointed to from within a local class.)  */
2903           if (TYPE_CONTEXT (type)
2904               && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL
2905               && !processing_template_decl)
2906             VARRAY_PUSH_TREE (local_classes, type);
2907
2908           if (!uses_template_parms (type))
2909             {
2910               if (flag_new_abi)
2911                 DECL_ASSEMBLER_NAME (d) = mangle_type (type);
2912               else
2913                 DECL_ASSEMBLER_NAME (d)
2914                   = get_identifier (build_overload_name (type, 1, 1));
2915             }
2916         }
2917       if (b->parm_flag == 2)
2918         {
2919           if (!COMPLETE_TYPE_P (current_class_type))
2920             CLASSTYPE_TAGS (current_class_type) = b->tags;
2921         }
2922     }
2923
2924   if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2925     /* Use the canonical TYPE_DECL for this node.  */
2926     TYPE_STUB_DECL (type) = TYPE_NAME (type);
2927   else
2928     {
2929       /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2930          will be the tagged type we just added to the current
2931          binding level.  This fake NULL-named TYPE_DECL node helps
2932          dwarfout.c to know when it needs to output a
2933          representation of a tagged type, and it also gives us a
2934          convenient place to record the "scope start" address for
2935          the tagged type.  */
2936
2937       tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2938       TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2939     }
2940 }
2941
2942 /* Counter used to create anonymous type names.  */
2943
2944 static int anon_cnt = 0;
2945
2946 /* Return an IDENTIFIER which can be used as a name for
2947    anonymous structs and unions.  */
2948
2949 tree
2950 make_anon_name ()
2951 {
2952   char buf[32];
2953
2954   sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2955   return get_identifier (buf);
2956 }
2957
2958 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2959    This keeps dbxout from getting confused.  */
2960
2961 void
2962 clear_anon_tags ()
2963 {
2964   register struct binding_level *b;
2965   register tree tags;
2966   static int last_cnt = 0;
2967
2968   /* Fast out if no new anon names were declared.  */
2969   if (last_cnt == anon_cnt)
2970     return;
2971
2972   b = current_binding_level;
2973   while (b->tag_transparent)
2974     b = b->level_chain;
2975   tags = b->tags;
2976   while (tags)
2977     {
2978       /* A NULL purpose means we have already processed all tags
2979          from here to the end of the list.  */
2980       if (TREE_PURPOSE (tags) == NULL_TREE)
2981         break;
2982       if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2983         TREE_PURPOSE (tags) = NULL_TREE;
2984       tags = TREE_CHAIN (tags);
2985     }
2986   last_cnt = anon_cnt;
2987 }
2988 \f
2989 /* Subroutine of duplicate_decls: return truthvalue of whether
2990    or not types of these decls match.
2991
2992    For C++, we must compare the parameter list so that `int' can match
2993    `int&' in a parameter position, but `int&' is not confused with
2994    `const int&'.  */
2995
2996 int
2997 decls_match (newdecl, olddecl)
2998      tree newdecl, olddecl;
2999 {
3000   int types_match;
3001
3002   if (newdecl == olddecl)
3003     return 1;
3004
3005   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
3006     /* If the two DECLs are not even the same kind of thing, we're not
3007        interested in their types.  */
3008     return 0;
3009
3010   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3011     {
3012       tree f1 = TREE_TYPE (newdecl);
3013       tree f2 = TREE_TYPE (olddecl);
3014       tree p1 = TYPE_ARG_TYPES (f1);
3015       tree p2 = TYPE_ARG_TYPES (f2);
3016
3017       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
3018           && ! (DECL_EXTERN_C_P (newdecl)
3019                 && DECL_EXTERN_C_P (olddecl)))
3020         return 0;
3021
3022       if (TREE_CODE (f1) != TREE_CODE (f2))
3023         return 0;
3024
3025       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
3026         {
3027           if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
3028               && (DECL_BUILT_IN (olddecl)
3029 #ifndef NO_IMPLICIT_EXTERN_C
3030                   || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
3031                   || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
3032 #endif
3033               ))
3034             {
3035               types_match = self_promoting_args_p (p1);
3036               if (p1 == void_list_node)
3037                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
3038             }
3039 #ifndef NO_IMPLICIT_EXTERN_C
3040           else if (p1 == NULL_TREE
3041                    && (DECL_EXTERN_C_P (olddecl)
3042                        && DECL_IN_SYSTEM_HEADER (olddecl)
3043                        && !DECL_CLASS_SCOPE_P (olddecl))
3044                    && (DECL_EXTERN_C_P (newdecl)
3045                        && DECL_IN_SYSTEM_HEADER (newdecl)
3046                        && !DECL_CLASS_SCOPE_P (newdecl)))
3047             {
3048               types_match = self_promoting_args_p (p2);
3049               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
3050             }
3051 #endif
3052           else
3053             types_match = compparms (p1, p2);
3054         }
3055       else
3056         types_match = 0;
3057     }
3058   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3059     {
3060       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3061                                 DECL_TEMPLATE_PARMS (olddecl)))
3062         return 0;
3063
3064       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
3065           != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
3066         return 0;
3067
3068       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3069         types_match = 1;
3070       else
3071         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
3072                                    DECL_TEMPLATE_RESULT (newdecl));
3073     }
3074   else
3075     {
3076       if (TREE_TYPE (newdecl) == error_mark_node)
3077         types_match = TREE_TYPE (olddecl) == error_mark_node;
3078       else if (TREE_TYPE (olddecl) == NULL_TREE)
3079         types_match = TREE_TYPE (newdecl) == NULL_TREE;
3080       else if (TREE_TYPE (newdecl) == NULL_TREE)
3081         types_match = 0;
3082       else
3083         types_match = comptypes (TREE_TYPE (newdecl),
3084                                  TREE_TYPE (olddecl),
3085                                  COMPARE_REDECLARATION);
3086     }
3087
3088   return types_match;
3089 }
3090
3091 /* If NEWDECL is `static' and an `extern' was seen previously,
3092    warn about it.  OLDDECL is the previous declaration.
3093
3094    Note that this does not apply to the C++ case of declaring
3095    a variable `extern const' and then later `const'.
3096
3097    Don't complain about built-in functions, since they are beyond
3098    the user's control.  */
3099
3100 static void
3101 warn_extern_redeclared_static (newdecl, olddecl)
3102      tree newdecl, olddecl;
3103 {
3104   static const char *explicit_extern_static_warning
3105     = "`%D' was declared `extern' and later `static'";
3106   static const char *implicit_extern_static_warning
3107     = "`%D' was declared implicitly `extern' and later `static'";
3108
3109   tree name;
3110
3111   if (TREE_CODE (newdecl) == TYPE_DECL
3112       || TREE_CODE (newdecl) == TEMPLATE_DECL
3113       || TREE_CODE (newdecl) == CONST_DECL)
3114     return;
3115
3116   /* Don't get confused by static member functions; that's a different
3117      use of `static'.  */
3118   if (TREE_CODE (newdecl) == FUNCTION_DECL
3119       && DECL_STATIC_FUNCTION_P (newdecl))
3120     return;
3121
3122   /* If the old declaration was `static', or the new one isn't, then
3123      then everything is OK.  */
3124   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
3125     return;
3126
3127   /* It's OK to declare a builtin function as `static'.  */
3128   if (TREE_CODE (olddecl) == FUNCTION_DECL
3129       && DECL_ARTIFICIAL (olddecl))
3130     return;
3131
3132   name = DECL_ASSEMBLER_NAME (newdecl);
3133   cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
3134               ? implicit_extern_static_warning
3135               : explicit_extern_static_warning, newdecl);
3136   cp_pedwarn_at ("previous declaration of `%D'", olddecl);
3137 }
3138
3139 /* Handle when a new declaration NEWDECL has the same name as an old
3140    one OLDDECL in the same binding contour.  Prints an error message
3141    if appropriate.
3142
3143    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
3144    Otherwise, return 0.  */
3145
3146 int
3147 duplicate_decls (newdecl, olddecl)
3148      tree newdecl, olddecl;
3149 {
3150   unsigned olddecl_uid = DECL_UID (olddecl);
3151   int olddecl_friend = 0, types_match = 0;
3152   int new_defines_function = 0;
3153
3154   if (newdecl == olddecl)
3155     return 1;
3156
3157   types_match = decls_match (newdecl, olddecl);
3158
3159   /* If either the type of the new decl or the type of the old decl is an
3160      error_mark_node, then that implies that we have already issued an
3161      error (earlier) for some bogus type specification, and in that case,
3162      it is rather pointless to harass the user with yet more error message
3163      about the same declaration, so just pretend the types match here.  */
3164   if (TREE_TYPE (newdecl) == error_mark_node
3165       || TREE_TYPE (olddecl) == error_mark_node)
3166     types_match = 1;
3167
3168   /* Check for redeclaration and other discrepancies. */
3169   if (TREE_CODE (olddecl) == FUNCTION_DECL
3170       && DECL_ARTIFICIAL (olddecl))
3171     {
3172       if (TREE_CODE (newdecl) != FUNCTION_DECL)
3173         {
3174           /* If you declare a built-in or predefined function name as static,
3175              the old definition is overridden, but optionally warn this was a
3176              bad choice of name.  */
3177           if (! TREE_PUBLIC (newdecl))
3178             {
3179               if (warn_shadow)
3180                 cp_warning ("shadowing %s function `%#D'",
3181                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3182                             olddecl);
3183               /* Discard the old built-in function.  */
3184               return 0;
3185             }
3186           /* If the built-in is not ansi, then programs can override
3187              it even globally without an error.  */
3188           else if (! DECL_BUILT_IN (olddecl))
3189             cp_warning ("library function `%#D' redeclared as non-function `%#D'",
3190                         olddecl, newdecl);
3191           else
3192             {
3193               cp_error ("declaration of `%#D'", newdecl);
3194               cp_error ("conflicts with built-in declaration `%#D'",
3195                         olddecl);
3196             }
3197           return 0;
3198         }
3199       else if (!types_match)
3200         {
3201           if ((DECL_EXTERN_C_P (newdecl)
3202                && DECL_EXTERN_C_P (olddecl))
3203               || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3204                             TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3205             {
3206               /* A near match; override the builtin.  */
3207
3208               if (TREE_PUBLIC (newdecl))
3209                 {
3210                   cp_warning ("new declaration `%#D'", newdecl);
3211                   cp_warning ("ambiguates built-in declaration `%#D'",
3212                               olddecl);
3213                 }
3214               else if (warn_shadow)
3215                 cp_warning ("shadowing %s function `%#D'",
3216                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3217                             olddecl);
3218             }
3219           else
3220             /* Discard the old built-in function.  */
3221             return 0;
3222         }
3223
3224       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3225         {
3226           /* If a builtin function is redeclared as `static', merge
3227              the declarations, but make the original one static.  */
3228           DECL_THIS_STATIC (olddecl) = 1;
3229           TREE_PUBLIC (olddecl) = 0;
3230
3231           /* Make the old declaration consistent with the new one so
3232              that all remnants of the builtin-ness of this function
3233              will be banished.  */
3234           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3235           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3236           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3237           SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (newdecl),
3238                                        newdecl);
3239         }
3240     }
3241   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3242     {
3243       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3244            && TREE_CODE (newdecl) != TYPE_DECL
3245            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3246                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3247           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3248               && TREE_CODE (olddecl) != TYPE_DECL
3249               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3250                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3251                         == TYPE_DECL))))
3252         {
3253           /* We do nothing special here, because C++ does such nasty
3254              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
3255              get shadowed, and know that if we need to find a TYPE_DECL
3256              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3257              slot of the identifier.  */
3258           return 0;
3259         }
3260
3261       if ((TREE_CODE (newdecl) == FUNCTION_DECL
3262            && DECL_FUNCTION_TEMPLATE_P (olddecl))
3263           || (TREE_CODE (olddecl) == FUNCTION_DECL
3264               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3265         return 0;
3266
3267       cp_error ("`%#D' redeclared as different kind of symbol", newdecl);
3268       if (TREE_CODE (olddecl) == TREE_LIST)
3269         olddecl = TREE_VALUE (olddecl);
3270       cp_error_at ("previous declaration of `%#D'", olddecl);
3271
3272       /* New decl is completely inconsistent with the old one =>
3273          tell caller to replace the old one.  */
3274
3275       return 0;
3276     }
3277   else if (!types_match)
3278     {
3279       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
3280         /* These are certainly not duplicate declarations; they're
3281            from different scopes.  */
3282         return 0;
3283
3284       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3285         {
3286           /* The name of a class template may not be declared to refer to
3287              any other template, class, function, object, namespace, value,
3288              or type in the same scope.  */
3289           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3290               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3291             {
3292               cp_error ("declaration of template `%#D'", newdecl);
3293               cp_error_at ("conflicts with previous declaration `%#D'",
3294                            olddecl);
3295             }
3296           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3297                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3298                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3299                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3300                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3301                                            DECL_TEMPLATE_PARMS (olddecl)))
3302             {
3303               cp_error ("new declaration `%#D'", newdecl);
3304               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3305             }
3306           return 0;
3307         }
3308       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3309         {
3310           if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
3311             {
3312               cp_error ("declaration of C function `%#D' conflicts with",
3313                         newdecl);
3314               cp_error_at ("previous declaration `%#D' here", olddecl);
3315             }
3316           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3317                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3318             {
3319               cp_error ("new declaration `%#D'", newdecl);
3320               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3321             }
3322           else
3323             return 0;
3324         }
3325
3326       /* Already complained about this, so don't do so again.  */
3327       else if (current_class_type == NULL_TREE
3328           || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3329         {
3330           cp_error ("conflicting types for `%#D'", newdecl);
3331           cp_error_at ("previous declaration as `%#D'", olddecl);
3332         }
3333     }
3334   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3335             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3336                  && (!DECL_TEMPLATE_INFO (newdecl)
3337                      || (DECL_TI_TEMPLATE (newdecl)
3338                          != DECL_TI_TEMPLATE (olddecl))))
3339                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3340                     && (!DECL_TEMPLATE_INFO (olddecl)
3341                         || (DECL_TI_TEMPLATE (olddecl)
3342                             != DECL_TI_TEMPLATE (newdecl))))))
3343     /* It's OK to have a template specialization and a non-template
3344        with the same type, or to have specializations of two
3345        different templates with the same type.  Note that if one is a
3346        specialization, and the other is an instantiation of the same
3347        template, that we do not exit at this point.  That situation
3348        can occur if we instantiate a template class, and then
3349        specialize one of its methods.  This situation is legal, but
3350        the declarations must be merged in the usual way.  */
3351     return 0;
3352   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3353            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3354                 && !DECL_USE_TEMPLATE (newdecl))
3355                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3356                    && !DECL_USE_TEMPLATE (olddecl))))
3357     /* One of the declarations is a template instantiation, and the
3358        other is not a template at all.  That's OK.  */
3359     return 0;
3360   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3361            && DECL_NAMESPACE_ALIAS (newdecl)
3362            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3363     /* Redeclaration of namespace alias, ignore it. */
3364     return 1;
3365   else
3366     {
3367       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3368       if (errmsg)
3369         {
3370           cp_error (errmsg, newdecl);
3371           if (DECL_NAME (olddecl) != NULL_TREE)
3372             cp_error_at ((DECL_INITIAL (olddecl)
3373                           && namespace_bindings_p ())
3374                          ? "`%#D' previously defined here"
3375                          : "`%#D' previously declared here", olddecl);
3376         }
3377       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3378                && DECL_INITIAL (olddecl) != NULL_TREE
3379                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3380                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3381         {
3382           /* Prototype decl follows defn w/o prototype.  */
3383           cp_warning_at ("prototype for `%#D'", newdecl);
3384           cp_warning_at ("follows non-prototype definition here", olddecl);
3385         }
3386       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3387                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3388         {
3389           /* extern "C" int foo ();
3390              int foo () { bar (); }
3391              is OK.  */
3392           if (current_lang_stack
3393               == &VARRAY_TREE (current_lang_base, 0))
3394             DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3395           else
3396             {
3397               cp_error_at ("previous declaration of `%#D' with %L linkage",
3398                            olddecl, DECL_LANGUAGE (olddecl));
3399               cp_error ("conflicts with new declaration with %L linkage",
3400                         DECL_LANGUAGE (newdecl));
3401             }
3402         }
3403
3404       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3405         ;
3406       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3407         {
3408           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3409           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3410           int i = 1;
3411
3412           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3413             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3414
3415           for (; t1 && t1 != void_list_node;
3416                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3417             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3418               {
3419                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3420                                            TREE_PURPOSE (t2)))
3421                   {
3422                     if (pedantic)
3423                       {
3424                         cp_pedwarn ("default argument given for parameter %d of `%#D'",
3425                                     i, newdecl);
3426                         cp_pedwarn_at ("after previous specification in `%#D'",
3427                                        olddecl);
3428                       }
3429                   }
3430                 else
3431                   {
3432                     cp_error ("default argument given for parameter %d of `%#D'",
3433                               i, newdecl);
3434                     cp_error_at ("after previous specification in `%#D'",
3435                                  olddecl);
3436                   }
3437               }
3438
3439           if (DECL_THIS_INLINE (newdecl) && ! DECL_THIS_INLINE (olddecl)
3440               && TREE_ADDRESSABLE (olddecl) && warn_inline)
3441             {
3442               cp_warning ("`%#D' was used before it was declared inline",
3443                           newdecl);
3444               cp_warning_at ("previous non-inline declaration here",
3445                              olddecl);
3446             }
3447         }
3448     }
3449
3450   /* If new decl is `static' and an `extern' was seen previously,
3451      warn about it.  */
3452   warn_extern_redeclared_static (newdecl, olddecl);
3453
3454   /* We have committed to returning 1 at this point.  */
3455   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3456     {
3457       /* Now that functions must hold information normally held
3458          by field decls, there is extra work to do so that
3459          declaration information does not get destroyed during
3460          definition.  */
3461       if (DECL_VINDEX (olddecl))
3462         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3463       if (DECL_VIRTUAL_CONTEXT (olddecl))
3464         DECL_VIRTUAL_CONTEXT (newdecl) = DECL_VIRTUAL_CONTEXT (olddecl);
3465       if (DECL_CONTEXT (olddecl))
3466         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3467       if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
3468         DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3469       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3470       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3471       DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3472       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3473       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3474       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3475       DECL_LANG_SPECIFIC (newdecl)->u2 = DECL_LANG_SPECIFIC (olddecl)->u2;
3476       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3477
3478       /* Optionally warn about more than one declaration for the same
3479          name, but don't warn about a function declaration followed by a
3480          definition.  */
3481       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3482           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3483           /* Don't warn about extern decl followed by definition. */
3484           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3485           /* Don't warn about friends, let add_friend take care of it. */
3486           && ! DECL_FRIEND_P (newdecl))
3487         {
3488           cp_warning ("redundant redeclaration of `%D' in same scope", newdecl);
3489           cp_warning_at ("previous declaration of `%D'", olddecl);
3490         }
3491     }
3492
3493   /* Deal with C++: must preserve virtual function table size.  */
3494   if (TREE_CODE (olddecl) == TYPE_DECL)
3495     {
3496       register tree newtype = TREE_TYPE (newdecl);
3497       register tree oldtype = TREE_TYPE (olddecl);
3498
3499       if (newtype != error_mark_node && oldtype != error_mark_node
3500           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3501         {
3502           CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
3503           CLASSTYPE_FRIEND_CLASSES (newtype)
3504             = CLASSTYPE_FRIEND_CLASSES (oldtype);
3505         }
3506
3507       DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
3508     }
3509
3510   /* Copy all the DECL_... slots specified in the new decl
3511      except for any that we copy here from the old type.  */
3512   DECL_MACHINE_ATTRIBUTES (newdecl)
3513     = merge_machine_decl_attributes (olddecl, newdecl);
3514
3515   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3516     {
3517       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3518       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3519         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3520                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3521
3522       return 1;
3523     }
3524
3525   if (types_match)
3526     {
3527       /* Automatically handles default parameters.  */
3528       tree oldtype = TREE_TYPE (olddecl);
3529       tree newtype;
3530
3531       /* Merge the data types specified in the two decls.  */
3532       newtype = common_type (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3533
3534       /* If common_type produces a non-typedef type, just use the old type.  */
3535       if (TREE_CODE (newdecl) == TYPE_DECL
3536           && newtype == DECL_ORIGINAL_TYPE (newdecl))
3537         newtype = oldtype;
3538
3539       if (TREE_CODE (newdecl) == VAR_DECL)
3540         DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3541       /* Do this after calling `common_type' so that default
3542          parameters don't confuse us.  */
3543       else if (TREE_CODE (newdecl) == FUNCTION_DECL
3544           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3545               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3546         {
3547           TREE_TYPE (newdecl) = build_exception_variant (newtype,
3548                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3549           TREE_TYPE (olddecl) = build_exception_variant (newtype,
3550                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
3551
3552           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3553               && DECL_SOURCE_LINE (olddecl) != 0
3554               && flag_exceptions
3555               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3556                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3557             {
3558               cp_error ("declaration of `%F' throws different exceptions",
3559                         newdecl);
3560               cp_error_at ("than previous declaration `%F'", olddecl);
3561             }
3562         }
3563       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3564
3565       /* Lay the type out, unless already done.  */
3566       if (! same_type_p (newtype, oldtype)
3567           && TREE_TYPE (newdecl) != error_mark_node
3568           && !(processing_template_decl && uses_template_parms (newdecl)))
3569         layout_type (TREE_TYPE (newdecl));
3570
3571       if ((TREE_CODE (newdecl) == VAR_DECL
3572            || TREE_CODE (newdecl) == PARM_DECL
3573            || TREE_CODE (newdecl) == RESULT_DECL
3574            || TREE_CODE (newdecl) == FIELD_DECL
3575            || TREE_CODE (newdecl) == TYPE_DECL)
3576           && !(processing_template_decl && uses_template_parms (newdecl)))
3577         layout_decl (newdecl, 0);
3578
3579       /* Merge the type qualifiers.  */
3580       if (TREE_READONLY (newdecl))
3581         TREE_READONLY (olddecl) = 1;
3582       if (TREE_THIS_VOLATILE (newdecl))
3583         TREE_THIS_VOLATILE (olddecl) = 1;
3584
3585       /* Merge the initialization information.  */
3586       if (DECL_INITIAL (newdecl) == NULL_TREE
3587           && DECL_INITIAL (olddecl) != NULL_TREE)
3588         {
3589           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3590           DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
3591           DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
3592           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3593               && DECL_LANG_SPECIFIC (newdecl)
3594               && DECL_LANG_SPECIFIC (olddecl))
3595             DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3596         }
3597
3598       /* Merge the section attribute.
3599          We want to issue an error if the sections conflict but that must be
3600          done later in decl_attributes since we are called before attributes
3601          are assigned.  */
3602       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3603         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3604
3605       /* Keep the old rtl since we can safely use it.  */
3606       DECL_RTL (newdecl) = DECL_RTL (olddecl);
3607
3608       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3609         {
3610           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3611             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3612           DECL_NO_CHECK_MEMORY_USAGE (newdecl)
3613             |= DECL_NO_CHECK_MEMORY_USAGE (olddecl);
3614           DECL_NO_LIMIT_STACK (newdecl)
3615             |= DECL_NO_LIMIT_STACK (olddecl);
3616         }
3617     }
3618   /* If cannot merge, then use the new type and qualifiers,
3619      and don't preserve the old rtl.  */
3620   else
3621     {
3622       /* Clean out any memory we had of the old declaration.  */
3623       tree oldstatic = value_member (olddecl, static_aggregates);
3624       if (oldstatic)
3625         TREE_VALUE (oldstatic) = error_mark_node;
3626
3627       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3628       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3629       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3630       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3631     }
3632
3633   /* Merge the storage class information.  */
3634   DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
3635   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3636   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3637   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3638   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3639   if (! DECL_EXTERNAL (olddecl))
3640     DECL_EXTERNAL (newdecl) = 0;
3641
3642   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3643     {
3644       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3645       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3646       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3647       DECL_TEMPLATE_INSTANTIATED (newdecl)
3648         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3649       /* Don't really know how much of the language-specific
3650          values we should copy from old to new.  */
3651       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3652       DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
3653       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3654       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3655       olddecl_friend = DECL_FRIEND_P (olddecl);
3656
3657       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
3658       if (TREE_CODE (newdecl) == FUNCTION_DECL
3659           || DECL_FUNCTION_TEMPLATE_P (newdecl))
3660         DECL_BEFRIENDING_CLASSES (newdecl)
3661           = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3662                      DECL_BEFRIENDING_CLASSES (olddecl));
3663     }
3664
3665   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3666     {
3667       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3668           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3669         {
3670           /* If newdecl is not a specialization, then it is not a
3671              template-related function at all.  And that means that we
3672              shoud have exited above, returning 0.  */
3673           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3674                               0);
3675
3676           if (TREE_USED (olddecl))
3677             /* From [temp.expl.spec]:
3678
3679                If a template, a member template or the member of a class
3680                template is explicitly specialized then that
3681                specialization shall be declared before the first use of
3682                that specialization that would cause an implicit
3683                instantiation to take place, in every translation unit in
3684                which such a use occurs.  */
3685             cp_error ("explicit specialization of %D after first use",
3686                       olddecl);
3687
3688           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3689         }
3690       DECL_THIS_INLINE (newdecl) |= DECL_THIS_INLINE (olddecl);
3691
3692       /* If either decl says `inline', this fn is inline, unless its
3693          definition was passed already.  */
3694       if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3695         DECL_INLINE (olddecl) = 1;
3696       DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3697
3698       if (! types_match)
3699         {
3700           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3701           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3702           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3703         }
3704       if (! types_match || new_defines_function)
3705         {
3706           /* These need to be copied so that the names are available.
3707              Note that if the types do match, we'll preserve inline
3708              info and other bits, but if not, we won't.  */
3709           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3710           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3711         }
3712       if (new_defines_function)
3713         /* If defining a function declared with other language
3714            linkage, use the previously declared language linkage.  */
3715         DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3716       else if (types_match)
3717         {
3718           /* If redeclaring a builtin function, and not a definition,
3719              it stays built in.  */
3720           if (DECL_BUILT_IN (olddecl))
3721             {
3722               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3723               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3724               /* If we're keeping the built-in definition, keep the rtl,
3725                  regardless of declaration matches.  */
3726               DECL_RTL (newdecl) = DECL_RTL (olddecl);
3727             }
3728           else
3729             DECL_FRAME_SIZE (newdecl) = DECL_FRAME_SIZE (olddecl);
3730
3731           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3732           if ((DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl)))
3733             /* Previously saved insns go together with
3734                the function's previous definition.  */
3735             DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3736           /* Don't clear out the arguments if we're redefining a function.  */
3737           if (DECL_ARGUMENTS (olddecl))
3738             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3739         }
3740     }
3741
3742   if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3743     {
3744       NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3745     }
3746
3747   /* Now preserve various other info from the definition.  */
3748   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3749   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3750   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3751   DECL_ASSEMBLER_NAME (newdecl) = DECL_ASSEMBLER_NAME (olddecl);
3752
3753   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3754     {
3755       int function_size;
3756
3757       function_size = sizeof (struct tree_decl);
3758
3759       bcopy ((char *) newdecl + sizeof (struct tree_common),
3760              (char *) olddecl + sizeof (struct tree_common),
3761              function_size - sizeof (struct tree_common));
3762
3763       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3764         {
3765           /* If newdecl is a template instantiation, it is possible that
3766              the following sequence of events has occurred:
3767
3768              o A friend function was declared in a class template.  The
3769              class template was instantiated.
3770
3771              o The instantiation of the friend declaration was
3772              recorded on the instantiation list, and is newdecl.
3773
3774              o Later, however, instantiate_class_template called pushdecl
3775              on the newdecl to perform name injection.  But, pushdecl in
3776              turn called duplicate_decls when it discovered that another
3777              declaration of a global function with the same name already
3778              existed.
3779
3780              o Here, in duplicate_decls, we decided to clobber newdecl.
3781
3782              If we're going to do that, we'd better make sure that
3783              olddecl, and not newdecl, is on the list of
3784              instantiations so that if we try to do the instantiation
3785              again we won't get the clobbered declaration.  */
3786
3787           tree tmpl = DECL_TI_TEMPLATE (newdecl);
3788           tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3789
3790           for (; decls; decls = TREE_CHAIN (decls))
3791             if (TREE_VALUE (decls) == newdecl)
3792               TREE_VALUE (decls) = olddecl;
3793         }
3794     }
3795   else
3796     {
3797       bcopy ((char *) newdecl + sizeof (struct tree_common),
3798              (char *) olddecl + sizeof (struct tree_common),
3799              sizeof (struct tree_decl) - sizeof (struct tree_common)
3800              + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
3801     }
3802
3803   DECL_UID (olddecl) = olddecl_uid;
3804   if (olddecl_friend)
3805     DECL_FRIEND_P (olddecl) = 1;
3806
3807   /* NEWDECL contains the merged attribute lists.
3808      Update OLDDECL to be the same.  */
3809   DECL_MACHINE_ATTRIBUTES (olddecl) = DECL_MACHINE_ATTRIBUTES (newdecl);
3810
3811   return 1;
3812 }
3813
3814 /* Record a decl-node X as belonging to the current lexical scope.
3815    Check for errors (such as an incompatible declaration for the same
3816    name already seen in the same scope).
3817
3818    Returns either X or an old decl for the same name.
3819    If an old decl is returned, it may have been smashed
3820    to agree with what X says.  */
3821
3822 tree
3823 pushdecl (x)
3824      tree x;
3825 {
3826   register tree t;
3827   register tree name;
3828   int need_new_binding;
3829
3830   /* We shouldn't be calling pushdecl when we're generating RTL for a
3831      function that we already did semantic analysis on previously.  */
3832   my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3833                       19990913);
3834
3835   need_new_binding = 1;
3836
3837   if (DECL_TEMPLATE_PARM_P (x))
3838     /* Template parameters have no context; they are not X::T even
3839        when declared within a class or namespace.  */
3840     ;
3841   else
3842     {
3843       if (current_function_decl && x != current_function_decl
3844           /* A local declaration for a function doesn't constitute
3845              nesting.  */
3846           && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3847           /* A local declaration for an `extern' variable is in the
3848              scope of the current namespace, not the current
3849              function.  */
3850           && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3851           && !DECL_CONTEXT (x))
3852         DECL_CONTEXT (x) = current_function_decl;
3853
3854       /* If this is the declaration for a namespace-scope function,
3855          but the declaration itself is in a local scope, mark the
3856          declaration.  */
3857       if (TREE_CODE (x) == FUNCTION_DECL
3858           && DECL_NAMESPACE_SCOPE_P (x)
3859           && current_function_decl
3860           && x != current_function_decl)
3861         DECL_LOCAL_FUNCTION_P (x) = 1;
3862     }
3863
3864   name = DECL_NAME (x);
3865   if (name)
3866     {
3867       int different_binding_level = 0;
3868
3869       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3870         name = TREE_OPERAND (name, 0);
3871
3872       /* In case this decl was explicitly namespace-qualified, look it
3873          up in its namespace context.  */
3874       if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x)
3875           && namespace_bindings_p ())
3876         t = namespace_binding (name, DECL_CONTEXT (x));
3877       else
3878         t = lookup_name_current_level (name);
3879
3880       /* [basic.link] If there is a visible declaration of an entity
3881          with linkage having the same name and type, ignoring entities
3882          declared outside the innermost enclosing namespace scope, the
3883          block scope declaration declares that same entity and
3884          receives the linkage of the previous declaration.  */
3885       if (! t && current_function_decl && x != current_function_decl
3886           && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
3887           && DECL_EXTERNAL (x))
3888         {
3889           /* Look in block scope.  */
3890           t = IDENTIFIER_VALUE (name);
3891           /* Or in the innermost namespace.  */
3892           if (! t)
3893             t = namespace_binding (name, DECL_CONTEXT (x));
3894           /* Does it have linkage?  */
3895           if (t && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
3896             t = NULL_TREE;
3897           if (t)
3898             different_binding_level = 1;
3899         }
3900
3901       /* If we are declaring a function, and the result of name-lookup
3902          was an OVERLOAD, look for an overloaded instance that is
3903          actually the same as the function we are declaring.  (If
3904          there is one, we have to merge our declaration with the
3905          previous declaration.)  */
3906       if (t && TREE_CODE (t) == OVERLOAD)
3907         {
3908           tree match;
3909
3910           if (TREE_CODE (x) == FUNCTION_DECL)
3911             for (match = t; match; match = OVL_NEXT (match))
3912               {
3913                 if (DECL_ASSEMBLER_NAME (OVL_CURRENT (t))
3914                     == DECL_ASSEMBLER_NAME (x))
3915                   break;
3916               }
3917           else
3918             /* Just choose one.  */
3919             match = t;
3920
3921           if (match)
3922             t = OVL_CURRENT (match);
3923           else
3924             t = NULL_TREE;
3925         }
3926
3927       if (t == error_mark_node)
3928         {
3929           /* error_mark_node is 0 for a while during initialization!  */
3930           t = NULL_TREE;
3931           cp_error_at ("`%#D' used prior to declaration", x);
3932         }
3933       else if (t != NULL_TREE)
3934         {
3935           if (different_binding_level)
3936             {
3937               if (decls_match (x, t))
3938                 /* The standard only says that the local extern
3939                    inherits linkage from the previous decl; in
3940                    particular, default args are not shared.  It would
3941                    be nice to propagate inlining info, though.  FIXME.  */
3942                 TREE_PUBLIC (x) = TREE_PUBLIC (t);
3943             }
3944           else if (TREE_CODE (t) == PARM_DECL)
3945             {
3946               if (DECL_CONTEXT (t) == NULL_TREE)
3947                 fatal ("parse errors have confused me too much");
3948
3949               /* Check for duplicate params.  */
3950               if (duplicate_decls (x, t))
3951                 return t;
3952             }
3953           else if ((DECL_EXTERN_C_FUNCTION_P (x)
3954                     || DECL_FUNCTION_TEMPLATE_P (x))
3955                    && is_overloaded_fn (t))
3956             /* Don't do anything just yet. */;
3957           else if (t == wchar_decl_node)
3958             {
3959               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3960                 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x));
3961
3962               /* Throw away the redeclaration.  */
3963               return t;
3964             }
3965           else if (TREE_CODE (t) != TREE_CODE (x))
3966             {
3967               if (duplicate_decls (x, t))
3968                 return t;
3969             }
3970           else if (duplicate_decls (x, t))
3971             {
3972               if (TREE_CODE (t) == TYPE_DECL)
3973                 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3974               else if (TREE_CODE (t) == FUNCTION_DECL)
3975                 check_default_args (t);
3976
3977               return t;
3978             }
3979           else if (DECL_MAIN_P (x))
3980             {
3981               /* A redeclaration of main, but not a duplicate of the
3982                  previous one.
3983
3984                  [basic.start.main]
3985
3986                  This function shall not be overloaded.  */
3987               cp_error_at ("invalid redeclaration of `%D'", t);
3988               cp_error ("as `%D'", x);
3989               /* We don't try to push this declaration since that
3990                  causes a crash.  */
3991               return x;
3992             }
3993         }
3994
3995       check_template_shadow (x);
3996
3997       /* If this is a function conjured up by the backend, massage it
3998          so it looks friendly.  */
3999       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
4000         {
4001           retrofit_lang_decl (x);
4002           DECL_LANGUAGE (x) = lang_c;
4003         }
4004
4005       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
4006         {
4007           t = push_overloaded_decl (x, PUSH_LOCAL);
4008           if (t != x)
4009             return t;
4010           if (!namespace_bindings_p ())
4011             /* We do not need to create a binding for this name;
4012                push_overloaded_decl will have already done so if
4013                necessary.  */
4014             need_new_binding = 0;
4015         }
4016       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
4017         {
4018           t = push_overloaded_decl (x, PUSH_GLOBAL);
4019           if (t == x)
4020             add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
4021           return t;
4022         }
4023
4024       /* If declaring a type as a typedef, copy the type (unless we're
4025          at line 0), and install this TYPE_DECL as the new type's typedef
4026          name.  See the extensive comment in ../c-decl.c (pushdecl). */
4027       if (TREE_CODE (x) == TYPE_DECL)
4028         {
4029           tree type = TREE_TYPE (x);
4030           if (DECL_SOURCE_LINE (x) == 0)
4031             {
4032               if (TYPE_NAME (type) == 0)
4033                 TYPE_NAME (type) = x;
4034             }
4035           else if (type != error_mark_node && TYPE_NAME (type) != x
4036                    /* We don't want to copy the type when all we're
4037                       doing is making a TYPE_DECL for the purposes of
4038                       inlining.  */
4039                    && (!TYPE_NAME (type)
4040                        || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
4041             {
4042               DECL_ORIGINAL_TYPE (x) = type;
4043               type = build_type_copy (type);
4044               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
4045               TYPE_NAME (type) = x;
4046               TREE_TYPE (x) = type;
4047             }
4048
4049           if (type != error_mark_node
4050               && TYPE_NAME (type)
4051               && TYPE_IDENTIFIER (type))
4052             set_identifier_type_value_with_scope (DECL_NAME (x), type,
4053                                                   current_binding_level);
4054
4055         }
4056
4057       /* Multiple external decls of the same identifier ought to match.
4058
4059          We get warnings about inline functions where they are defined.
4060          We get warnings about other functions from push_overloaded_decl.
4061
4062          Avoid duplicate warnings where they are used.  */
4063       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
4064         {
4065           tree decl;
4066
4067           decl = IDENTIFIER_NAMESPACE_VALUE (name);
4068           if (decl && TREE_CODE (decl) == OVERLOAD)
4069             decl = OVL_FUNCTION (decl);
4070
4071           if (decl && decl != error_mark_node
4072               && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
4073               /* If different sort of thing, we already gave an error.  */
4074               && TREE_CODE (decl) == TREE_CODE (x)
4075               && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
4076             {
4077               cp_pedwarn ("type mismatch with previous external decl", x);
4078               cp_pedwarn_at ("previous external decl of `%#D'", decl);
4079             }
4080         }
4081
4082       /* This name is new in its binding level.
4083          Install the new declaration and return it.  */
4084       if (namespace_bindings_p ())
4085         {
4086           /* Install a global value.  */
4087
4088           /* If the first global decl has external linkage,
4089              warn if we later see static one.  */
4090           if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
4091             TREE_PUBLIC (name) = 1;
4092
4093           /* Bind the mangled name for the entity.  In the future, we
4094              should not need to do this; mangled names are an
4095              implementation detail of which the front-end should not
4096              need to be aware.  */
4097           if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
4098                 && t != NULL_TREE)
4099               /* For an ordinary function, we create a binding from
4100                  the mangled name (i.e., NAME) to the DECL.  But, for
4101                  an `extern "C"' function, the mangled name and the
4102                  ordinary name are the same so we need not do this.  */
4103               && !DECL_EXTERN_C_FUNCTION_P (x))
4104             {
4105               tree mangled_name;
4106
4107               if (TREE_CODE (x) == TYPE_DECL || TREE_CODE (x) == VAR_DECL
4108                   || TREE_CODE (x) == NAMESPACE_DECL)
4109                 mangled_name = name;
4110               else
4111                 mangled_name = DECL_ASSEMBLER_NAME (x);
4112
4113               if (TREE_CODE (x) == FUNCTION_DECL)
4114                 my_friendly_assert
4115                   ((IDENTIFIER_GLOBAL_VALUE (mangled_name) == NULL_TREE)
4116                   || (IDENTIFIER_GLOBAL_VALUE (mangled_name) == x), 378);
4117               SET_IDENTIFIER_NAMESPACE_VALUE (mangled_name, x);
4118             }
4119
4120           /* Don't forget if the function was used via an implicit decl.  */
4121           if (IDENTIFIER_IMPLICIT_DECL (name)
4122               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
4123             TREE_USED (x) = 1;
4124
4125           /* Don't forget if its address was taken in that way.  */
4126           if (IDENTIFIER_IMPLICIT_DECL (name)
4127               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
4128             TREE_ADDRESSABLE (x) = 1;
4129
4130           /* Warn about mismatches against previous implicit decl.  */
4131           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
4132               /* If this real decl matches the implicit, don't complain.  */
4133               && ! (TREE_CODE (x) == FUNCTION_DECL
4134                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
4135             cp_warning
4136               ("`%D' was previously implicitly declared to return `int'", x);
4137
4138           /* If new decl is `static' and an `extern' was seen previously,
4139              warn about it.  */
4140           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
4141             warn_extern_redeclared_static (x, t);
4142         }
4143       else
4144         {
4145           /* Here to install a non-global value.  */
4146           tree oldlocal = IDENTIFIER_VALUE (name);
4147           tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
4148
4149           if (need_new_binding)
4150             {
4151               push_local_binding (name, x, 0);
4152               /* Because push_local_binding will hook X on to the
4153                  current_binding_level's name list, we don't want to
4154                  do that again below.  */
4155               need_new_binding = 0;
4156             }
4157
4158           /* If this is a TYPE_DECL, push it into the type value slot.  */
4159           if (TREE_CODE (x) == TYPE_DECL)
4160             set_identifier_type_value_with_scope (name, TREE_TYPE (x),
4161                                                   current_binding_level);
4162
4163           /* Clear out any TYPE_DECL shadowed by a namespace so that
4164              we won't think this is a type.  The C struct hack doesn't
4165              go through namespaces.  */
4166           if (TREE_CODE (x) == NAMESPACE_DECL)
4167             set_identifier_type_value_with_scope (name, NULL_TREE,
4168                                                   current_binding_level);
4169
4170           if (oldlocal)
4171             {
4172               tree d = oldlocal;
4173
4174               while (oldlocal
4175                      && TREE_CODE (oldlocal) == VAR_DECL
4176                      && DECL_DEAD_FOR_LOCAL (oldlocal))
4177                 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
4178
4179               if (oldlocal == NULL_TREE)
4180                 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
4181             }
4182
4183           /* If this is an extern function declaration, see if we
4184              have a global definition or declaration for the function.  */
4185           if (oldlocal == NULL_TREE
4186               && DECL_EXTERNAL (x)
4187               && oldglobal != NULL_TREE
4188               && TREE_CODE (x) == FUNCTION_DECL
4189               && TREE_CODE (oldglobal) == FUNCTION_DECL)
4190             {
4191               /* We have one.  Their types must agree.  */
4192               if (decls_match (x, oldglobal))
4193                 /* OK */;
4194               else
4195                 {
4196                   cp_warning ("extern declaration of `%#D' doesn't match", x);
4197                   cp_warning_at ("global declaration `%#D'", oldglobal);
4198                 }
4199             }
4200           /* If we have a local external declaration,
4201              and no file-scope declaration has yet been seen,
4202              then if we later have a file-scope decl it must not be static.  */
4203           if (oldlocal == NULL_TREE
4204               && oldglobal == NULL_TREE
4205               && DECL_EXTERNAL (x)
4206               && TREE_PUBLIC (x))
4207             TREE_PUBLIC (name) = 1;
4208
4209           /* Warn if shadowing an argument at the top level of the body.  */
4210           if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
4211               /* Inline decls shadow nothing.  */
4212               && !DECL_FROM_INLINE (x)
4213               && TREE_CODE (oldlocal) == PARM_DECL
4214               /* Don't complain if it's from an enclosing function.  */
4215               && DECL_CONTEXT (oldlocal) == current_function_decl
4216               && TREE_CODE (x) != PARM_DECL)
4217             {
4218               /* Go to where the parms should be and see if we
4219                  find them there.  */
4220               struct binding_level *b = current_binding_level->level_chain;
4221
4222               if (cleanup_label)
4223                 b = b->level_chain;
4224
4225               /* ARM $8.3 */
4226               if (b->parm_flag == 1)
4227                 cp_error ("declaration of `%#D' shadows a parameter", name);
4228             }
4229
4230           /* Maybe warn if shadowing something else.  */
4231           if (warn_shadow && !DECL_EXTERNAL (x)
4232               /* Inline decls shadow nothing.  */
4233               && !DECL_FROM_INLINE (x)
4234               /* No shadow warnings for internally generated vars.  */
4235               && ! DECL_ARTIFICIAL (x)
4236               /* No shadow warnings for vars made for inlining.  */
4237               && ! DECL_FROM_INLINE (x))
4238             {
4239               if (oldlocal != NULL_TREE && TREE_CODE (oldlocal) == PARM_DECL)
4240                 warning ("declaration of `%s' shadows a parameter",
4241                         IDENTIFIER_POINTER (name));
4242               else if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4243                        && current_class_ptr
4244                        && !TREE_STATIC (name))
4245                 warning ("declaration of `%s' shadows a member of `this'",
4246                         IDENTIFIER_POINTER (name));
4247               else if (oldlocal != NULL_TREE)
4248                 warning ("declaration of `%s' shadows previous local",
4249                         IDENTIFIER_POINTER (name));
4250               else if (oldglobal != NULL_TREE)
4251                 /* XXX shadow warnings in outer-more namespaces */
4252                 warning ("declaration of `%s' shadows global declaration",
4253                         IDENTIFIER_POINTER (name));
4254             }
4255         }
4256
4257       if (TREE_CODE (x) == FUNCTION_DECL)
4258         check_default_args (x);
4259
4260       /* Keep count of variables in this level with incomplete type.  */
4261       if (TREE_CODE (x) == VAR_DECL
4262           && TREE_TYPE (x) != error_mark_node
4263           && ((!COMPLETE_TYPE_P (TREE_TYPE (x))
4264                && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
4265               /* RTTI TD entries are created while defining the type_info.  */
4266               || (TYPE_LANG_SPECIFIC (TREE_TYPE (x))
4267                   && TYPE_BEING_DEFINED (TREE_TYPE (x)))))
4268         {
4269           if (namespace_bindings_p ())
4270             namespace_scope_incomplete
4271               = tree_cons (NULL_TREE, x, namespace_scope_incomplete);
4272           else
4273             current_binding_level->incomplete
4274               = tree_cons (NULL_TREE, x, current_binding_level->incomplete);
4275         }
4276     }
4277
4278   if (need_new_binding)
4279     add_decl_to_level (x,
4280                        DECL_NAMESPACE_SCOPE_P (x)
4281                        ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4282                        : current_binding_level);
4283
4284   return x;
4285 }
4286
4287 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
4288    caller to set DECL_CONTEXT properly.  */
4289
4290 static tree
4291 pushdecl_with_scope (x, level)
4292      tree x;
4293      struct binding_level *level;
4294 {
4295   register struct binding_level *b;
4296   tree function_decl = current_function_decl;
4297
4298   current_function_decl = NULL_TREE;
4299   if (level->parm_flag == 2)
4300     {
4301       b = class_binding_level;
4302       class_binding_level = level;
4303       pushdecl_class_level (x);
4304       class_binding_level = b;
4305     }
4306   else
4307     {
4308       b = current_binding_level;
4309       current_binding_level = level;
4310       x = pushdecl (x);
4311       current_binding_level = b;
4312     }
4313   current_function_decl = function_decl;
4314   return x;
4315 }
4316
4317 /* Like pushdecl, only it places X in the current namespace,
4318    if appropriate.  */
4319
4320 tree
4321 pushdecl_namespace_level (x)
4322      tree x;
4323 {
4324   register struct binding_level *b = current_binding_level;
4325   register tree t;
4326
4327   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4328
4329   /* Now, the type_shadowed stack may screw us.  Munge it so it does
4330      what we want.  */
4331   if (TREE_CODE (x) == TYPE_DECL)
4332     {
4333       tree name = DECL_NAME (x);
4334       tree newval;
4335       tree *ptr = (tree *)0;
4336       for (; b != global_binding_level; b = b->level_chain)
4337         {
4338           tree shadowed = b->type_shadowed;
4339           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4340             if (TREE_PURPOSE (shadowed) == name)
4341               {
4342                 ptr = &TREE_VALUE (shadowed);
4343                 /* Can't break out of the loop here because sometimes
4344                    a binding level will have duplicate bindings for
4345                    PT names.  It's gross, but I haven't time to fix it.  */
4346               }
4347         }
4348       newval = TREE_TYPE (x);
4349       if (ptr == (tree *)0)
4350         {
4351           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
4352              up here if this is changed to an assertion.  --KR  */
4353           SET_IDENTIFIER_TYPE_VALUE (name, newval);
4354         }
4355       else
4356         {
4357           *ptr = newval;
4358         }
4359     }
4360   return t;
4361 }
4362
4363 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4364    if appropriate.  */
4365
4366 tree
4367 pushdecl_top_level (x)
4368      tree x;
4369 {
4370   push_to_top_level ();
4371   x = pushdecl_namespace_level (x);
4372   pop_from_top_level ();
4373   return x;
4374 }
4375
4376 /* Make the declaration of X appear in CLASS scope.  */
4377
4378 void
4379 pushdecl_class_level (x)
4380      tree x;
4381 {
4382   /* Don't use DECL_ASSEMBLER_NAME here!  Everything that looks in class
4383      scope looks for the pre-mangled name.  */
4384   register tree name;
4385
4386   if (TREE_CODE (x) == OVERLOAD)
4387     x = OVL_CURRENT (x);
4388   name = DECL_NAME (x);
4389
4390   if (name)
4391     {
4392       push_class_level_binding (name, x);
4393       if (TREE_CODE (x) == TYPE_DECL)
4394         set_identifier_type_value (name, TREE_TYPE (x));
4395     }
4396   else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4397     {
4398       tree f;
4399
4400       for (f = TYPE_FIELDS (TREE_TYPE (x));
4401            f;
4402            f = TREE_CHAIN (f))
4403         pushdecl_class_level (f);
4404     }
4405 }
4406
4407 /* Enter DECL into the symbol table, if that's appropriate.  Returns
4408    DECL, or a modified version thereof.  */
4409
4410 tree
4411 maybe_push_decl (decl)
4412      tree decl;
4413 {
4414   tree type = TREE_TYPE (decl);
4415
4416   /* Add this decl to the current binding level, but not if it comes
4417      from another scope, e.g. a static member variable.  TEM may equal
4418      DECL or it may be a previous decl of the same name.  */
4419   if (decl == error_mark_node
4420       || (TREE_CODE (decl) != PARM_DECL
4421           && DECL_CONTEXT (decl) != NULL_TREE
4422           /* Definitions of namespace members outside their namespace are
4423              possible. */
4424           && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4425       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4426       || TREE_CODE (type) == UNKNOWN_TYPE
4427       /* The declaration of a template specialization does not affect
4428          the functions available for overload resolution, so we do not
4429          call pushdecl.  */
4430       || (TREE_CODE (decl) == FUNCTION_DECL
4431           && DECL_TEMPLATE_SPECIALIZATION (decl)))
4432     return decl;
4433   else
4434     return pushdecl (decl);
4435 }
4436
4437 /* Make the declaration(s) of X appear in CLASS scope
4438    under the name NAME.  */
4439
4440 void
4441 push_class_level_binding (name, x)
4442      tree name;
4443      tree x;
4444 {
4445   tree binding;
4446   /* The class_binding_level will be NULL if x is a template
4447      parameter name in a member template.  */
4448   if (!class_binding_level)
4449     return;
4450
4451   /* Make sure that this new member does not have the same name
4452      as a template parameter.  */
4453   if (TYPE_BEING_DEFINED (current_class_type))
4454     check_template_shadow (x);
4455
4456   /* If this declaration shadows a declaration from an enclosing
4457      class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4458      we leave this class.  Record the shadowed declaration here.  */
4459   binding = IDENTIFIER_BINDING (name);
4460   if (binding
4461       && ((TREE_CODE (x) == OVERLOAD
4462            && BINDING_VALUE (binding)
4463            && is_overloaded_fn (BINDING_VALUE (binding)))
4464           || INHERITED_VALUE_BINDING_P (binding)))
4465     {
4466       tree shadow;
4467       tree old_decl;
4468
4469       /* If the old binding was from a base class, and was for a tag
4470          name, slide it over to make room for the new binding.  The
4471          old binding is still visible if explicitly qualified with a
4472          class-key.  */
4473       if (INHERITED_VALUE_BINDING_P (binding)
4474           && BINDING_VALUE (binding)
4475           && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4476           && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4477           && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4478         {
4479           old_decl = BINDING_TYPE (binding);
4480           BINDING_TYPE (binding) = BINDING_VALUE (binding);
4481           BINDING_VALUE (binding) = NULL_TREE;
4482           INHERITED_VALUE_BINDING_P (binding) = 0;
4483         }
4484       else
4485         old_decl = BINDING_VALUE (binding);
4486
4487       /* There was already a binding for X containing fewer
4488          functions than are named in X.  Find the previous
4489          declaration of X on the class-shadowed list, and update it.  */
4490       for (shadow = class_binding_level->class_shadowed;
4491            shadow;
4492            shadow = TREE_CHAIN (shadow))
4493         if (TREE_PURPOSE (shadow) == name
4494             && TREE_TYPE (shadow) == old_decl)
4495           {
4496             BINDING_VALUE (binding) = x;
4497             INHERITED_VALUE_BINDING_P (binding) = 0;
4498             TREE_TYPE (shadow) = x;
4499             return;
4500           }
4501     }
4502
4503   /* If we didn't replace an existing binding, put the binding on the
4504      stack of bindings for the identifier, and update
4505      IDENTIFIER_CLASS_VALUE.  */
4506   if (push_class_binding (name, x))
4507     {
4508       class_binding_level->class_shadowed
4509         = tree_cons (name, IDENTIFIER_CLASS_VALUE (name),
4510                      class_binding_level->class_shadowed);
4511       /* Record the value we are binding NAME to so that we can know
4512          what to pop later.  */
4513       TREE_TYPE (class_binding_level->class_shadowed) = x;
4514     }
4515 }
4516
4517 /* Insert another USING_DECL into the current binding level, returning
4518    this declaration. If this is a redeclaration, do nothing, and
4519    return NULL_TREE if this not in namespace scope (in namespace
4520    scope, a using decl might extend any previous bindings).  */
4521
4522 tree
4523 push_using_decl (scope, name)
4524      tree scope;
4525      tree name;
4526 {
4527   tree decl;
4528
4529   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4530   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4531   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4532     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4533       break;
4534   if (decl)
4535     return namespace_bindings_p () ? decl : NULL_TREE;
4536   decl = build_lang_decl (USING_DECL, name, void_type_node);
4537   DECL_INITIAL (decl) = scope;
4538   TREE_CHAIN (decl) = current_binding_level->usings;
4539   current_binding_level->usings = decl;
4540   return decl;
4541 }
4542
4543 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4544    changed (i.e. there was already a directive), or the fresh
4545    TREE_LIST otherwise.  */
4546
4547 tree
4548 push_using_directive (used)
4549      tree used;
4550 {
4551   tree ud = current_binding_level->using_directives;
4552   tree iter, ancestor;
4553
4554   /* Check if we already have this. */
4555   if (purpose_member (used, ud) != NULL_TREE)
4556     return NULL_TREE;
4557
4558   /* Recursively add all namespaces used. */
4559   for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4560     push_using_directive (TREE_PURPOSE (iter));
4561
4562   ancestor = namespace_ancestor (current_decl_namespace (), used);
4563   ud = current_binding_level->using_directives;
4564   ud = tree_cons (used, ancestor, ud);
4565   current_binding_level->using_directives = ud;
4566   return ud;
4567 }
4568
4569 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4570    other definitions already in place.  We get around this by making
4571    the value of the identifier point to a list of all the things that
4572    want to be referenced by that name.  It is then up to the users of
4573    that name to decide what to do with that list.
4574
4575    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
4576    DECL_TEMPLATE_RESULT.  It is dealt with the same way.
4577
4578    FLAGS is a bitwise-or of the following values:
4579      PUSH_LOCAL: Bind DECL in the current scope, rather than at
4580                  namespace scope.
4581      PUSH_USING: DECL is being pushed as the result of a using
4582                  declaration.
4583
4584    The value returned may be a previous declaration if we guessed wrong
4585    about what language DECL should belong to (C or C++).  Otherwise,
4586    it's always DECL (and never something that's not a _DECL).  */
4587
4588 tree
4589 push_overloaded_decl (decl, flags)
4590      tree decl;
4591      int flags;
4592 {
4593   tree name = DECL_NAME (decl);
4594   tree old;
4595   tree new_binding;
4596   int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4597
4598   if (doing_global)
4599     old = namespace_binding (name, DECL_CONTEXT (decl));
4600   else
4601     old = lookup_name_current_level (name);
4602
4603   if (old)
4604     {
4605       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4606         {
4607           tree t = TREE_TYPE (old);
4608           if (IS_AGGR_TYPE (t) && warn_shadow
4609               && (! DECL_IN_SYSTEM_HEADER (decl)
4610                   || ! DECL_IN_SYSTEM_HEADER (old)))
4611             cp_warning ("`%#D' hides constructor for `%#T'", decl, t);
4612           old = NULL_TREE;
4613         }
4614       else if (is_overloaded_fn (old))
4615         {
4616           tree tmp;
4617
4618           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4619             {
4620               tree fn = OVL_CURRENT (tmp);
4621
4622               if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4623                   && !(flags & PUSH_USING)
4624                   && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4625                                 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4626                 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4627                           decl, fn);
4628
4629               if (duplicate_decls (decl, fn))
4630                 return fn;
4631             }
4632         }
4633       else if (old == error_mark_node)
4634         /* Ignore the undefined symbol marker.  */
4635         old = NULL_TREE;
4636       else
4637         {
4638           cp_error_at ("previous non-function declaration `%#D'", old);
4639           cp_error ("conflicts with function declaration `%#D'", decl);
4640           return decl;
4641         }
4642     }
4643
4644   if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4645     {
4646       if (old && TREE_CODE (old) != OVERLOAD)
4647         new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4648       else
4649         new_binding = ovl_cons (decl, old);
4650       if (flags & PUSH_USING)
4651         OVL_USED (new_binding) = 1;
4652     }
4653   else
4654     /* NAME is not ambiguous.  */
4655     new_binding = decl;
4656
4657   if (doing_global)
4658     set_namespace_binding (name, current_namespace, new_binding);
4659   else
4660     {
4661       /* We only create an OVERLOAD if there was a previous binding at
4662          this level, or if decl is a template. In the former case, we
4663          need to remove the old binding and replace it with the new
4664          binding.  We must also run through the NAMES on the binding
4665          level where the name was bound to update the chain.  */
4666
4667       if (TREE_CODE (new_binding) == OVERLOAD && old)
4668         {
4669           tree *d;
4670
4671           for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4672                *d;
4673                d = &TREE_CHAIN (*d))
4674             if (*d == old
4675                 || (TREE_CODE (*d) == TREE_LIST
4676                     && TREE_VALUE (*d) == old))
4677               {
4678                 if (TREE_CODE (*d) == TREE_LIST)
4679                   /* Just replace the old binding with the new.  */
4680                   TREE_VALUE (*d) = new_binding;
4681                 else
4682                   /* Build a TREE_LIST to wrap the OVERLOAD.  */
4683                   *d = tree_cons (NULL_TREE, new_binding,
4684                                   TREE_CHAIN (*d));
4685
4686                 /* And update the CPLUS_BINDING node.  */
4687                 BINDING_VALUE (IDENTIFIER_BINDING (name))
4688                   = new_binding;
4689                 return decl;
4690               }
4691
4692           /* We should always find a previous binding in this case.  */
4693           my_friendly_abort (0);
4694         }
4695
4696       /* Install the new binding.  */
4697       push_local_binding (name, new_binding, flags);
4698     }
4699
4700   return decl;
4701 }
4702 \f
4703 /* Generate an implicit declaration for identifier FUNCTIONID
4704    as a function of type int ().  Print a warning if appropriate.  */
4705
4706 tree
4707 implicitly_declare (functionid)
4708      tree functionid;
4709 {
4710   register tree decl;
4711
4712   /* We used to reuse an old implicit decl here,
4713      but this loses with inline functions because it can clobber
4714      the saved decl chains.  */
4715   decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4716
4717   DECL_EXTERNAL (decl) = 1;
4718   TREE_PUBLIC (decl) = 1;
4719
4720   /* ISO standard says implicit declarations are in the innermost block.
4721      So we record the decl in the standard fashion.  */
4722   pushdecl (decl);
4723   rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
4724
4725   if (warn_implicit
4726       /* Only one warning per identifier.  */
4727       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4728     {
4729       cp_pedwarn ("implicit declaration of function `%#D'", decl);
4730     }
4731
4732   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4733
4734   return decl;
4735 }
4736
4737 /* Return zero if the declaration NEWDECL is valid
4738    when the declaration OLDDECL (assumed to be for the same name)
4739    has already been seen.
4740    Otherwise return an error message format string with a %s
4741    where the identifier should go.  */
4742
4743 static const char *
4744 redeclaration_error_message (newdecl, olddecl)
4745      tree newdecl, olddecl;
4746 {
4747   if (TREE_CODE (newdecl) == TYPE_DECL)
4748     {
4749       /* Because C++ can put things into name space for free,
4750          constructs like "typedef struct foo { ... } foo"
4751          would look like an erroneous redeclaration.  */
4752       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4753         return 0;
4754       else
4755         return "redefinition of `%#D'";
4756     }
4757   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4758     {
4759       /* If this is a pure function, its olddecl will actually be
4760          the original initialization to `0' (which we force to call
4761          abort()).  Don't complain about redefinition in this case.  */
4762       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4763         return 0;
4764
4765       /* If both functions come from different namespaces, this is not
4766          a redeclaration - this is a conflict with a used function. */
4767       if (DECL_NAMESPACE_SCOPE_P (olddecl)
4768           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4769         return "`%D' conflicts with used function";
4770
4771       /* We'll complain about linkage mismatches in
4772          warn_extern_redeclared_static.  */
4773
4774       /* Defining the same name twice is no good.  */
4775       if (DECL_INITIAL (olddecl) != NULL_TREE
4776           && DECL_INITIAL (newdecl) != NULL_TREE)
4777         {
4778           if (DECL_NAME (olddecl) == NULL_TREE)
4779             return "`%#D' not declared in class";
4780           else
4781             return "redefinition of `%#D'";
4782         }
4783       return 0;
4784     }
4785   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4786     {
4787       if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4788            && (DECL_TEMPLATE_RESULT (newdecl)
4789                != DECL_TEMPLATE_RESULT (olddecl))
4790            && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4791            && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4792           || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4793               && COMPLETE_TYPE_P (TREE_TYPE (newdecl))
4794               && COMPLETE_TYPE_P (TREE_TYPE (olddecl))))
4795         return "redefinition of `%#D'";
4796       return 0;
4797     }
4798   else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
4799     {
4800       /* Objects declared at top level:  */
4801       /* If at least one is a reference, it's ok.  */
4802       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4803         return 0;
4804       /* Reject two definitions.  */
4805       return "redefinition of `%#D'";
4806     }
4807   else
4808     {
4809       /* Objects declared with block scope:  */
4810       /* Reject two definitions, and reject a definition
4811          together with an external reference.  */
4812       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4813         return "redeclaration of `%#D'";
4814       return 0;
4815     }
4816 }
4817 \f
4818 /* Create a new label, named ID.  */
4819
4820 static tree
4821 make_label_decl (id, local_p)
4822      tree id;
4823      int local_p;
4824 {
4825   tree decl;
4826
4827   decl = build_decl (LABEL_DECL, id, void_type_node);
4828   if (expanding_p)
4829     /* Make sure every label has an rtx.  */
4830     label_rtx (decl);
4831
4832   DECL_CONTEXT (decl) = current_function_decl;
4833   DECL_MODE (decl) = VOIDmode;
4834   C_DECLARED_LABEL_FLAG (decl) = local_p;
4835
4836   /* Say where one reference is to the label, for the sake of the
4837      error if it is not defined.  */
4838   DECL_SOURCE_LINE (decl) = lineno;
4839   DECL_SOURCE_FILE (decl) = input_filename;
4840
4841   /* Record the fact that this identifier is bound to this label.  */
4842   SET_IDENTIFIER_LABEL_VALUE (id, decl);
4843
4844   return decl;
4845 }
4846
4847 /* Record this label on the list of used labels so that we can check
4848    at the end of the function to see whether or not the label was
4849    actually defined, and so we can check when the label is defined whether
4850    this use is valid.  */
4851
4852 static void
4853 use_label (decl)
4854      tree decl;
4855 {
4856   if (named_label_uses == NULL
4857       || named_label_uses->names_in_scope != current_binding_level->names
4858       || named_label_uses->label_decl != decl)
4859     {
4860       struct named_label_use_list *new_ent;
4861       new_ent = ((struct named_label_use_list *)
4862                  ggc_alloc (sizeof (struct named_label_use_list)));
4863       new_ent->label_decl = decl;
4864       new_ent->names_in_scope = current_binding_level->names;
4865       new_ent->binding_level = current_binding_level;
4866       new_ent->lineno_o_goto = lineno;
4867       new_ent->filename_o_goto = input_filename;
4868       new_ent->next = named_label_uses;
4869       named_label_uses = new_ent;
4870     }
4871 }
4872
4873 /* Look for a label named ID in the current function.  If one cannot
4874    be found, create one.  (We keep track of used, but undefined,
4875    labels, and complain about them at the end of a function.)  */
4876
4877 tree
4878 lookup_label (id)
4879      tree id;
4880 {
4881   tree decl;
4882   struct named_label_list *ent;
4883
4884   /* You can't use labels at global scope.  */
4885   if (current_function_decl == NULL_TREE)
4886     {
4887       error ("label `%s' referenced outside of any function",
4888              IDENTIFIER_POINTER (id));
4889       return NULL_TREE;
4890     }
4891
4892   /* See if we've already got this label.  */
4893   decl = IDENTIFIER_LABEL_VALUE (id);
4894   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4895     return decl;
4896
4897   /* Record this label on the list of labels used in this function.
4898      We do this before calling make_label_decl so that we get the
4899      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
4900   ent = ((struct named_label_list *)
4901          ggc_alloc_cleared (sizeof (struct named_label_list)));
4902   ent->old_value = IDENTIFIER_LABEL_VALUE (id);
4903   ent->next = named_labels;
4904   named_labels = ent;
4905
4906   /* We need a new label.  */
4907   decl = make_label_decl (id, /*local_p=*/0);
4908
4909   /* Now fill in the information we didn't have before.  */
4910   ent->label_decl = decl;
4911
4912   return decl;
4913 }
4914
4915 /* Declare a local label named ID.  */
4916
4917 tree
4918 declare_local_label (id)
4919      tree id;
4920 {
4921   tree decl;
4922
4923   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4924      this scope we can restore the old value of
4925      IDENTIFIER_TYPE_VALUE.  */
4926   current_binding_level->shadowed_labels
4927     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4928                  current_binding_level->shadowed_labels);
4929   /* Look for the label.  */
4930   decl = make_label_decl (id, /*local_p=*/1);
4931   /* Now fill in the information we didn't have before.  */
4932   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4933
4934   return decl;
4935 }
4936
4937 /* Returns nonzero if it is ill-formed to jump past the declaration of
4938    DECL.  Returns 2 if it's also a real problem.  */
4939
4940 static int
4941 decl_jump_unsafe (decl)
4942      tree decl;
4943 {
4944   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
4945     return 0;
4946
4947   if (DECL_INITIAL (decl) == NULL_TREE
4948       && pod_type_p (TREE_TYPE (decl)))
4949     return 0;
4950
4951   /* This is really only important if we're crossing an initialization.
4952      The POD stuff is just pedantry; why should it matter if the class
4953      contains a field of pointer to member type?  */
4954   if (DECL_INITIAL (decl)
4955       || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
4956     return 2;
4957   return 1;
4958 }
4959
4960 /* Check that a single previously seen jump to a newly defined label
4961    is OK.  DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
4962    the jump context; NAMES are the names in scope in LEVEL at the jump
4963    context; FILE and LINE are the source position of the jump or 0.  */
4964
4965 static void
4966 check_previous_goto_1 (decl, level, names, file, line)
4967      tree decl;
4968      struct binding_level *level;
4969      tree names;
4970      const char *file;
4971      int line;
4972 {
4973   int identified = 0;
4974   int saw_eh = 0;
4975   struct binding_level *b = current_binding_level;
4976   for (; b; b = b->level_chain)
4977     {
4978       tree new_decls = b->names;
4979       tree old_decls = (b == level ? names : NULL_TREE);
4980       for (; new_decls != old_decls;
4981            new_decls = TREE_CHAIN (new_decls))
4982         {
4983           int problem = decl_jump_unsafe (new_decls);
4984           if (! problem)
4985             continue;
4986
4987           if (! identified)
4988             {
4989               if (decl)
4990                 cp_pedwarn ("jump to label `%D'", decl);
4991               else
4992                 pedwarn ("jump to case label");
4993
4994               if (file)
4995                 pedwarn_with_file_and_line (file, line, "  from here");
4996               identified = 1;
4997             }
4998
4999           if (problem > 1 && DECL_ARTIFICIAL (new_decls))
5000             /* Can't skip init of __exception_info.  */
5001             cp_error_at ("  enters catch block", new_decls);
5002           else if (problem > 1)
5003             cp_error_at ("  crosses initialization of `%#D'",
5004                          new_decls);
5005           else
5006             cp_pedwarn_at ("  enters scope of non-POD `%#D'",
5007                            new_decls);
5008         }
5009
5010       if (b == level)
5011         break;
5012       if (b->eh_region && ! saw_eh)
5013         {
5014           if (! identified)
5015             {
5016               if (decl)
5017                 cp_pedwarn ("jump to label `%D'", decl);
5018               else
5019                 pedwarn ("jump to case label");
5020
5021               if (file)
5022                 pedwarn_with_file_and_line (file, line, "  from here");
5023               identified = 1;
5024             }
5025           error ("  enters try block");
5026           saw_eh = 1;
5027         }
5028     }
5029 }
5030
5031 static void
5032 check_previous_goto (use)
5033      struct named_label_use_list *use;
5034 {
5035   check_previous_goto_1 (use->label_decl, use->binding_level,
5036                          use->names_in_scope, use->filename_o_goto,
5037                          use->lineno_o_goto);
5038 }
5039
5040 static void
5041 check_switch_goto (level)
5042      struct binding_level *level;
5043 {
5044   check_previous_goto_1 (NULL_TREE, level, level->names, NULL, 0);
5045 }
5046
5047 /* Check that any previously seen jumps to a newly defined label DECL
5048    are OK.  Called by define_label.  */
5049
5050 static void
5051 check_previous_gotos (decl)
5052      tree decl;
5053 {
5054   struct named_label_use_list **usep;
5055
5056   if (! TREE_USED (decl))
5057     return;
5058
5059   for (usep = &named_label_uses; *usep; )
5060     {
5061       struct named_label_use_list *use = *usep;
5062       if (use->label_decl == decl)
5063         {
5064           check_previous_goto (use);
5065           *usep = use->next;
5066         }
5067       else
5068         usep = &(use->next);
5069     }
5070 }
5071
5072 /* Check that a new jump to a label DECL is OK.  Called by
5073    finish_goto_stmt.  */
5074
5075 void
5076 check_goto (decl)
5077      tree decl;
5078 {
5079   int identified = 0;
5080   tree bad;
5081   struct named_label_list *lab;
5082
5083   /* We can't know where a computed goto is jumping.  So we assume
5084      that it's OK.  */
5085   if (! DECL_P (decl))
5086     return;
5087
5088   /* If the label hasn't been defined yet, defer checking.  */
5089   if (! DECL_INITIAL (decl))
5090     {
5091       use_label (decl);
5092       return;
5093     }
5094
5095   for (lab = named_labels; lab; lab = lab->next)
5096     if (decl == lab->label_decl)
5097       break;
5098
5099   /* If the label is not on named_labels it's a gcc local label, so
5100      it must be in an outer scope, so jumping to it is always OK.  */
5101   if (lab == 0)
5102     return;
5103
5104   if ((lab->eh_region || lab->bad_decls) && !identified)
5105     {
5106       cp_pedwarn_at ("jump to label `%D'", decl);
5107       pedwarn ("  from here");
5108       identified = 1;
5109     }
5110
5111   for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad))
5112     {
5113       tree b = TREE_VALUE (bad);
5114       int u = decl_jump_unsafe (b);
5115
5116       if (u > 1 && DECL_ARTIFICIAL (b))
5117         /* Can't skip init of __exception_info.  */
5118         cp_error_at ("  enters catch block", b);
5119       else if (u > 1)
5120         cp_error_at ("  skips initialization of `%#D'", b);
5121       else
5122         cp_pedwarn_at ("  enters scope of non-POD `%#D'", b);
5123     }
5124
5125   if (lab->eh_region)
5126     error ("  enters try block");
5127 }
5128
5129 /* Define a label, specifying the location in the source file.
5130    Return the LABEL_DECL node for the label, if the definition is valid.
5131    Otherwise return 0.  */
5132
5133 tree
5134 define_label (filename, line, name)
5135      const char *filename;
5136      int line;
5137      tree name;
5138 {
5139   tree decl = lookup_label (name);
5140   struct named_label_list *ent;
5141
5142   for (ent = named_labels; ent; ent = ent->next)
5143     if (ent->label_decl == decl)
5144       break;
5145
5146   /* After labels, make any new cleanups go into their
5147      own new (temporary) binding contour.  */
5148   current_binding_level->more_cleanups_ok = 0;
5149
5150   if (name == get_identifier ("wchar_t"))
5151     cp_pedwarn ("label named wchar_t");
5152
5153   if (DECL_INITIAL (decl) != NULL_TREE)
5154     {
5155       cp_error ("duplicate label `%D'", decl);
5156       return 0;
5157     }
5158   else
5159     {
5160       /* Mark label as having been defined.  */
5161       DECL_INITIAL (decl) = error_mark_node;
5162       /* Say where in the source.  */
5163       DECL_SOURCE_FILE (decl) = filename;
5164       DECL_SOURCE_LINE (decl) = line;
5165       if (ent)
5166         {
5167           ent->names_in_scope = current_binding_level->names;
5168           ent->binding_level = current_binding_level;
5169         }
5170       check_previous_gotos (decl);
5171       current_function_return_value = NULL_TREE;
5172       return decl;
5173     }
5174 }
5175
5176 struct cp_switch
5177 {
5178   struct binding_level *level;
5179   struct cp_switch *next;
5180   /* The SWITCH_STMT being built.  */
5181   tree switch_stmt;
5182   /* A splay-tree mapping the low element of a case range to the high
5183      element, or NULL_TREE if there is no high element.  Used to
5184      determine whether or not a new case label duplicates an old case
5185      label.  We need a tree, rather than simply a hash table, because
5186      of the GNU case range extension.  */
5187   splay_tree cases;
5188 };
5189
5190 /* A stack of the currently active switch statements.  The innermost
5191    switch statement is on the top of the stack.  There is no need to
5192    mark the stack for garbage collection because it is only active
5193    during the processing of the body of a function, and we never
5194    collect at that point.  */
5195
5196 static struct cp_switch *switch_stack;
5197
5198 static int
5199 case_compare (k1, k2)
5200      splay_tree_key k1;
5201      splay_tree_key k2;
5202 {
5203   /* Consider a NULL key (such as arises with a `default' label) to be
5204      smaller than anything else.  */
5205   if (!k1)
5206     return k2 ? -1 : 0;
5207   else if (!k2)
5208     return k1 ? 1 : 0;
5209
5210   return tree_int_cst_compare ((tree) k1, (tree) k2);
5211 }
5212
5213 /* Called right after a switch-statement condition is parsed.
5214    SWITCH_STMT is the switch statement being parsed.  */
5215
5216 void
5217 push_switch (switch_stmt)
5218      tree switch_stmt;
5219 {
5220   struct cp_switch *p
5221     = (struct cp_switch *) xmalloc (sizeof (struct cp_switch));
5222   p->level = current_binding_level;
5223   p->next = switch_stack;
5224   p->switch_stmt = switch_stmt;
5225   p->cases = splay_tree_new (case_compare, NULL, NULL);
5226   switch_stack = p;
5227 }
5228
5229 void
5230 pop_switch ()
5231 {
5232   struct cp_switch *cs;
5233
5234   cs = switch_stack;
5235   splay_tree_delete (cs->cases);
5236   switch_stack = switch_stack->next;
5237   free (cs);
5238 }
5239
5240 /* Note that we've seen a definition of a case label, and complain if this
5241    is a bad place for one.  */
5242
5243 void
5244 finish_case_label (low_value, high_value)
5245      tree low_value;
5246      tree high_value;
5247 {
5248   tree label;
5249   tree cleanup;
5250   tree type;
5251   tree cond;
5252   tree case_label;
5253   splay_tree_node node;
5254
5255   if (! switch_stack)
5256     {
5257       if (high_value)
5258         error ("case label not within a switch statement");
5259       else if (low_value)
5260         cp_error ("case label `%E' not within a switch statement",
5261                   low_value);
5262       else
5263         error ("`default' label not within a switch statement");
5264       return;
5265     }
5266
5267   label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
5268
5269   if (processing_template_decl)
5270     {
5271       /* For templates, just add the case label; we'll do semantic
5272          analysis at instantiation-time.  */
5273       add_stmt (build_case_label (low_value, high_value, label));
5274       return;
5275     }
5276
5277   /* Find the condition on which this switch statement depends.  */
5278   cond = SWITCH_COND (switch_stack->switch_stmt);
5279   if (cond && TREE_CODE (cond) == TREE_LIST)
5280     cond = TREE_VALUE (cond);
5281   /* If there was an error processing the switch condition, bail now
5282      before we get more confused.  */
5283   if (!cond || cond == error_mark_node)
5284     return;
5285   type = TREE_TYPE (cond);
5286
5287   if ((low_value && TREE_TYPE (low_value)
5288        && POINTER_TYPE_P (TREE_TYPE (low_value)))
5289       || (high_value && TREE_TYPE (high_value)
5290           && POINTER_TYPE_P (TREE_TYPE (high_value))))
5291     error ("pointers are not permitted as case values");
5292
5293   /* Case ranges are a GNU extension.  */
5294   if (high_value && pedantic)
5295     pedwarn ("ISO C++ forbids range expressions in switch statement");
5296
5297   if (low_value)
5298     {
5299       low_value = check_case_value (low_value);
5300       low_value = convert_and_check (type, low_value);
5301     }
5302   if (high_value)
5303     {
5304       high_value = check_case_value (high_value);
5305       high_value = convert_and_check (type, high_value);
5306     }
5307
5308   /* If an error has occurred, bail out now.  */
5309   if (low_value == error_mark_node || high_value == error_mark_node)
5310     return;
5311
5312   /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
5313      really a case range, even though it was written that way.  Remove
5314      the HIGH_VALUE to simplify later processing.  */
5315   if (tree_int_cst_equal (low_value, high_value))
5316     high_value = NULL_TREE;
5317   if (low_value && high_value
5318       && !tree_int_cst_lt (low_value, high_value))
5319     warning ("empty range specified");
5320
5321   /* Look up the LOW_VALUE in the table of case labels we already
5322      have.  */
5323   node = splay_tree_lookup (switch_stack->cases, (splay_tree_key) low_value);
5324   /* If there was not an exact match, check for overlapping ranges.
5325      There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
5326      that's a `default' label and the only overlap is an exact match.  */
5327   if (!node && (low_value || high_value))
5328     {
5329       splay_tree_node low_bound;
5330       splay_tree_node high_bound;
5331
5332       /* Even though there wasn't an exact match, there might be an
5333          overlap between this case range and another case range.
5334          Since we've (inductively) not allowed any overlapping case
5335          ranges, we simply need to find the greatest low case label
5336          that is smaller that LOW_VALUE, and the smallest low case
5337          label that is greater than LOW_VALUE.  If there is an overlap
5338          it will occur in one of these two ranges.  */
5339       low_bound = splay_tree_predecessor (switch_stack->cases,
5340                                           (splay_tree_key) low_value);
5341       high_bound = splay_tree_successor (switch_stack->cases,
5342                                          (splay_tree_key) low_value);
5343
5344       /* Check to see if the LOW_BOUND overlaps.  It is smaller than
5345          the LOW_VALUE, so there is no need to check unless the
5346          LOW_BOUND is in fact itself a case range.  */
5347       if (low_bound
5348           && CASE_HIGH ((tree) low_bound->value)
5349           && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
5350                                     low_value) >= 0)
5351         node = low_bound;
5352       /* Check to see if the HIGH_BOUND overlaps.  The low end of that
5353          range is bigger than the low end of the current range, so we
5354          are only interested if the current range is a real range, and
5355          not an ordinary case label.  */
5356       else if (high_bound
5357                && high_value
5358                && (tree_int_cst_compare ((tree) high_bound->key,
5359                                          high_value)
5360                    <= 0))
5361         node = high_bound;
5362     }
5363   /* If there was an overlap, issue an error.  */
5364   if (node)
5365     {
5366       tree duplicate = CASE_LABEL_DECL ((tree) node->value);
5367
5368       if (high_value)
5369         {
5370           error ("duplicate (or overlapping) case value");
5371           cp_error_at ("this is the first entry overlapping that value",
5372                        duplicate);
5373         }
5374       else if (low_value)
5375         {
5376           cp_error ("duplicate case value `%E'", low_value) ;
5377           cp_error_at ("previously used here", duplicate);
5378         }
5379       else
5380         {
5381           error ("multiple default labels in one switch");
5382           cp_error_at ("this is the first default label", duplicate);
5383         }
5384       return;
5385     }
5386
5387   cleanup = last_cleanup_this_contour ();
5388   if (cleanup)
5389     {
5390       static int explained = 0;
5391       cp_warning_at ("destructor needed for `%#D'", TREE_PURPOSE (cleanup));
5392       warning ("where case label appears here");
5393       if (!explained)
5394         {
5395           warning ("(enclose actions of previous case statements requiring destructors in their own scope.)");
5396           explained = 1;
5397         }
5398     }
5399
5400   check_switch_goto (switch_stack->level);
5401
5402   /* After labels, make any new cleanups go into their
5403      own new (temporary) binding contour.  */
5404   current_binding_level->more_cleanups_ok = 0;
5405   current_function_return_value = NULL_TREE;
5406
5407   /* Add a representation for the case label to the statement
5408      tree.  */
5409   case_label = build_case_label (low_value, high_value, label);
5410   add_stmt (case_label);
5411
5412   /* Register this case label in the splay tree.  */
5413   splay_tree_insert (switch_stack->cases,
5414                      (splay_tree_key) low_value,
5415                      (splay_tree_value) case_label);
5416 }
5417 \f
5418 /* Return the list of declarations of the current level.
5419    Note that this list is in reverse order unless/until
5420    you nreverse it; and when you do nreverse it, you must
5421    store the result back using `storedecls' or you will lose.  */
5422
5423 tree
5424 getdecls ()
5425 {
5426   return current_binding_level->names;
5427 }
5428
5429 /* Return the list of type-tags (for structs, etc) of the current level.  */
5430
5431 tree
5432 gettags ()
5433 {
5434   return current_binding_level->tags;
5435 }
5436
5437 /* Store the list of declarations of the current level.
5438    This is done for the parameter declarations of a function being defined,
5439    after they are modified in the light of any missing parameters.  */
5440
5441 static void
5442 storedecls (decls)
5443      tree decls;
5444 {
5445   current_binding_level->names = decls;
5446 }
5447
5448 /* Similarly, store the list of tags of the current level.  */
5449
5450 void
5451 storetags (tags)
5452      tree tags;
5453 {
5454   current_binding_level->tags = tags;
5455 }
5456 \f
5457 /* Given NAME, an IDENTIFIER_NODE,
5458    return the structure (or union or enum) definition for that name.
5459    Searches binding levels from BINDING_LEVEL up to the global level.
5460    If THISLEVEL_ONLY is nonzero, searches only the specified context
5461    (but skips any tag-transparent contexts to find one that is
5462    meaningful for tags).
5463    FORM says which kind of type the caller wants;
5464    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5465    If the wrong kind of type is found, and it's not a template, an error is
5466    reported.  */
5467
5468 static tree
5469 lookup_tag (form, name, binding_level, thislevel_only)
5470      enum tree_code form;
5471      tree name;
5472      struct binding_level *binding_level;
5473      int thislevel_only;
5474 {
5475   register struct binding_level *level;
5476   /* Non-zero if, we should look past a template parameter level, even
5477      if THISLEVEL_ONLY.  */
5478   int allow_template_parms_p = 1;
5479
5480   for (level = binding_level; level; level = level->level_chain)
5481     {
5482       register tree tail;
5483       if (ANON_AGGRNAME_P (name))
5484         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5485           {
5486             /* There's no need for error checking here, because
5487                anon names are unique throughout the compilation.  */
5488             if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
5489               return TREE_VALUE (tail);
5490           }
5491       else if (level->namespace_p)
5492         /* Do namespace lookup. */
5493         for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
5494           {
5495             tree old = binding_for_name (name, tail);
5496
5497             /* If we just skipped past a template parameter level,
5498                even though THISLEVEL_ONLY, and we find a template
5499                class declaration, then we use the _TYPE node for the
5500                template.  See the example below.  */
5501             if (thislevel_only && !allow_template_parms_p
5502                 && old && BINDING_VALUE (old)
5503                 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
5504               old = TREE_TYPE (BINDING_VALUE (old));
5505             else
5506               old = BINDING_TYPE (old);
5507
5508             /* If it has an original type, it is a typedef, and we
5509                should not return it.  */
5510             if (old && DECL_ORIGINAL_TYPE (TYPE_NAME (old)))
5511               old = NULL_TREE;
5512             if (old && TREE_CODE (old) != form
5513                 && !(form != ENUMERAL_TYPE && TREE_CODE (old) == TEMPLATE_DECL))
5514               {
5515                 cp_error ("`%#D' redeclared as %C", old, form);
5516                 return NULL_TREE;
5517               }
5518             if (old)
5519               return old;
5520             if (thislevel_only || tail == global_namespace)
5521               return NULL_TREE;
5522           }
5523       else
5524         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5525           {
5526             if (TREE_PURPOSE (tail) == name)
5527               {
5528                 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5529                 /* Should tighten this up; it'll probably permit
5530                    UNION_TYPE and a struct template, for example.  */
5531                 if (code != form
5532                     && !(form != ENUMERAL_TYPE && code == TEMPLATE_DECL))
5533                   {
5534                     /* Definition isn't the kind we were looking for.  */
5535                     cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
5536                               form);
5537                     return NULL_TREE;
5538                   }
5539                 return TREE_VALUE (tail);
5540               }
5541           }
5542       if (thislevel_only && ! level->tag_transparent)
5543         {
5544           if (level->template_parms_p && allow_template_parms_p)
5545             {
5546               /* We must deal with cases like this:
5547
5548                    template <class T> struct S;
5549                    template <class T> struct S {};
5550
5551                  When looking up `S', for the second declaration, we
5552                  would like to find the first declaration.  But, we
5553                  are in the pseudo-global level created for the
5554                  template parameters, rather than the (surrounding)
5555                  namespace level.  Thus, we keep going one more level,
5556                  even though THISLEVEL_ONLY is non-zero.  */
5557               allow_template_parms_p = 0;
5558               continue;
5559             }
5560           else
5561             return NULL_TREE;
5562         }
5563     }
5564   return NULL_TREE;
5565 }
5566
5567 #if 0
5568 void
5569 set_current_level_tags_transparency (tags_transparent)
5570      int tags_transparent;
5571 {
5572   current_binding_level->tag_transparent = tags_transparent;
5573 }
5574 #endif
5575
5576 /* Given a type, find the tag that was defined for it and return the tag name.
5577    Otherwise return 0.  However, the value can never be 0
5578    in the cases in which this is used.
5579
5580    C++: If NAME is non-zero, this is the new name to install.  This is
5581    done when replacing anonymous tags with real tag names.  */
5582
5583 static tree
5584 lookup_tag_reverse (type, name)
5585      tree type;
5586      tree name;
5587 {
5588   register struct binding_level *level;
5589
5590   for (level = current_binding_level; level; level = level->level_chain)
5591     {
5592       register tree tail;
5593       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5594         {
5595           if (TREE_VALUE (tail) == type)
5596             {
5597               if (name)
5598                 TREE_PURPOSE (tail) = name;
5599               return TREE_PURPOSE (tail);
5600             }
5601         }
5602     }
5603   return NULL_TREE;
5604 }
5605 \f
5606 /* Look up NAME in the NAMESPACE.  */
5607
5608 tree
5609 lookup_namespace_name (namespace, name)
5610      tree namespace, name;
5611 {
5612   tree val;
5613   tree template_id = NULL_TREE;
5614
5615   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5616
5617   if (TREE_CODE (name) == NAMESPACE_DECL)
5618     /* This happens for A::B<int> when B is a namespace. */
5619     return name;
5620   else if (TREE_CODE (name) == TEMPLATE_DECL)
5621     {
5622       /* This happens for A::B where B is a template, and there are no
5623          template arguments.  */
5624       cp_error ("invalid use of `%D'", name);
5625       return error_mark_node;
5626     }
5627
5628   namespace = ORIGINAL_NAMESPACE (namespace);
5629
5630   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5631     {
5632       template_id = name;
5633       name = TREE_OPERAND (name, 0);
5634       if (TREE_CODE (name) == OVERLOAD)
5635         name = DECL_NAME (OVL_CURRENT (name));
5636       else if (DECL_P (name))
5637         name = DECL_NAME (name);
5638     }
5639
5640   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5641
5642   val = make_node (CPLUS_BINDING);
5643   if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5644     return error_mark_node;
5645
5646   if (BINDING_VALUE (val))
5647     {
5648       val = BINDING_VALUE (val);
5649
5650       if (template_id)
5651         {
5652           if (DECL_CLASS_TEMPLATE_P (val))
5653             val = lookup_template_class (val,
5654                                          TREE_OPERAND (template_id, 1),
5655                                          /*in_decl=*/NULL_TREE,
5656                                          /*context=*/NULL_TREE,
5657                                          /*entering_scope=*/0);
5658           else if (DECL_FUNCTION_TEMPLATE_P (val)
5659                    || TREE_CODE (val) == OVERLOAD)
5660             val = lookup_template_function (val,
5661                                             TREE_OPERAND (template_id, 1));
5662           else
5663             {
5664               cp_error ("`%D::%D' is not a template",
5665                         namespace, name);
5666               return error_mark_node;
5667             }
5668         }
5669
5670       /* If we have a single function from a using decl, pull it out.  */
5671       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5672         val = OVL_FUNCTION (val);
5673       return val;
5674     }
5675
5676   cp_error ("`%D' undeclared in namespace `%D'", name, namespace);
5677   return error_mark_node;
5678 }
5679
5680 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
5681
5682 static unsigned long
5683 typename_hash (k)
5684      hash_table_key k;
5685 {
5686   unsigned long hash;
5687   tree t;
5688
5689   t = (tree) k;
5690   hash = (((unsigned long) TYPE_CONTEXT (t))
5691           ^ ((unsigned long) DECL_NAME (TYPE_NAME (t))));
5692
5693   return hash;
5694 }
5695
5696 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
5697
5698 static boolean
5699 typename_compare (k1, k2)
5700      hash_table_key k1;
5701      hash_table_key k2;
5702 {
5703   tree t1;
5704   tree t2;
5705   tree d1;
5706   tree d2;
5707
5708   t1 = (tree) k1;
5709   t2 = (tree) k2;
5710   d1 = TYPE_NAME (t1);
5711   d2 = TYPE_NAME (t2);
5712
5713   return (DECL_NAME (d1) == DECL_NAME (d2)
5714           && same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))
5715           && ((TREE_TYPE (t1) != NULL_TREE)
5716               == (TREE_TYPE (t2) != NULL_TREE))
5717           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5718           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5719 }
5720
5721 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
5722    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
5723    is non-NULL, this type is being created by the implicit typename
5724    extension, and BASE_TYPE is a type named `t' in some base class of
5725    `T' which depends on template parameters.
5726
5727    Returns the new TYPENAME_TYPE.  */
5728
5729 tree
5730 build_typename_type (context, name, fullname, base_type)
5731      tree context;
5732      tree name;
5733      tree fullname;
5734      tree base_type;
5735 {
5736   tree t;
5737   tree d;
5738   struct hash_entry* e;
5739
5740   static struct hash_table ht;
5741
5742   if (!ht.table)
5743     {
5744       static struct hash_table *h = &ht;
5745       if (!hash_table_init (&ht, &hash_newfunc, &typename_hash,
5746                             &typename_compare))
5747         fatal ("virtual memory exhausted");
5748       ggc_add_tree_hash_table_root (&h, 1);
5749     }
5750
5751   /* Build the TYPENAME_TYPE.  */
5752   t = make_aggr_type (TYPENAME_TYPE);
5753   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5754   TYPENAME_TYPE_FULLNAME (t) = fullname;
5755   TREE_TYPE (t) = base_type;
5756
5757   /* Build the corresponding TYPE_DECL.  */
5758   d = build_decl (TYPE_DECL, name, t);
5759   TYPE_NAME (TREE_TYPE (d)) = d;
5760   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5761   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5762   DECL_ARTIFICIAL (d) = 1;
5763
5764   /* See if we already have this type.  */
5765   e = hash_lookup (&ht, t, /*create=*/false, /*copy=*/0);
5766   if (e)
5767     t = (tree) e->key;
5768   else
5769     /* Insert the type into the table.  */
5770     hash_lookup (&ht, t, /*create=*/true, /*copy=*/0);
5771
5772   return t;
5773 }
5774
5775 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
5776    unless an error occurs, in which case error_mark_node is returned.
5777    If COMPLAIN zero, don't complain about any errors that occur.  */
5778
5779 tree
5780 make_typename_type (context, name, complain)
5781      tree context, name;
5782      int complain;
5783 {
5784   tree fullname;
5785
5786   if (TYPE_P (name))
5787     {
5788       if (!(TYPE_LANG_SPECIFIC (name)
5789             && (CLASSTYPE_IS_TEMPLATE (name)
5790                 || CLASSTYPE_USE_TEMPLATE (name))))
5791         name = TYPE_IDENTIFIER (name);
5792       else
5793         /* Create a TEMPLATE_ID_EXPR for the type.  */
5794         name = build_nt (TEMPLATE_ID_EXPR,
5795                          CLASSTYPE_TI_TEMPLATE (name),
5796                          CLASSTYPE_TI_ARGS (name));
5797     }
5798   else if (TREE_CODE (name) == TYPE_DECL)
5799     name = DECL_NAME (name);
5800
5801   fullname = name;
5802
5803   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5804     {
5805       name = TREE_OPERAND (name, 0);
5806       if (TREE_CODE (name) == TEMPLATE_DECL)
5807         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5808     }
5809   if (TREE_CODE (name) != IDENTIFIER_NODE)
5810     my_friendly_abort (2000);
5811
5812   if (TREE_CODE (context) == NAMESPACE_DECL)
5813     {
5814       /* We can get here from typename_sub0 in the explicit_template_type
5815          expansion.  Just fail.  */
5816       if (complain)
5817         cp_error ("no class template named `%#T' in `%#T'",
5818                   name, context);
5819       return error_mark_node;
5820     }
5821
5822   if (! uses_template_parms (context)
5823       || currently_open_class (context))
5824     {
5825       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5826         {
5827           tree tmpl = NULL_TREE;
5828           if (IS_AGGR_TYPE (context))
5829             tmpl = lookup_field (context, name, 0, 0);
5830           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5831             {
5832               if (complain)
5833                 cp_error ("no class template named `%#T' in `%#T'",
5834                           name, context);
5835               return error_mark_node;
5836             }
5837
5838           return lookup_template_class (tmpl,
5839                                         TREE_OPERAND (fullname, 1),
5840                                         NULL_TREE, context,
5841                                         /*entering_scope=*/0);
5842         }
5843       else
5844         {
5845           tree t;
5846
5847           if (!IS_AGGR_TYPE (context))
5848             {
5849               if (complain)
5850                 cp_error ("no type named `%#T' in `%#T'", name, context);
5851               return error_mark_node;
5852             }
5853
5854           t = lookup_field (context, name, 0, 1);
5855           if (t)
5856             return TREE_TYPE (t);
5857         }
5858     }
5859
5860   /* If the CONTEXT is not a template type, then either the field is
5861      there now or its never going to be.  */
5862   if (!uses_template_parms (context))
5863     {
5864       if (complain)
5865         cp_error ("no type named `%#T' in `%#T'", name, context);
5866       return error_mark_node;
5867     }
5868
5869
5870   return build_typename_type (context, name, fullname,  NULL_TREE);
5871 }
5872
5873 /* Select the right _DECL from multiple choices. */
5874
5875 static tree
5876 select_decl (binding, flags)
5877      tree binding;
5878      int flags;
5879 {
5880   tree val;
5881   val = BINDING_VALUE (binding);
5882   if (LOOKUP_NAMESPACES_ONLY (flags))
5883     {
5884       /* We are not interested in types. */
5885       if (val && TREE_CODE (val) == NAMESPACE_DECL)
5886         return val;
5887       return NULL_TREE;
5888     }
5889
5890   /* If we could have a type and
5891      we have nothing or we need a type and have none.  */
5892   if (BINDING_TYPE (binding)
5893       && (!val || ((flags & LOOKUP_PREFER_TYPES)
5894                    && TREE_CODE (val) != TYPE_DECL)))
5895     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5896   /* Don't return non-types if we really prefer types. */
5897   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
5898            && (TREE_CODE (val) != TEMPLATE_DECL
5899                || !DECL_CLASS_TEMPLATE_P (val)))
5900     val = NULL_TREE;
5901
5902   return val;
5903 }
5904
5905 /* Unscoped lookup of a global: iterate over current namespaces,
5906    considering using-directives.  If SPACESP is non-NULL, store a list
5907    of the namespaces we've considered in it.  */
5908
5909 tree
5910 unqualified_namespace_lookup (name, flags, spacesp)
5911      tree name;
5912      int flags;
5913      tree *spacesp;
5914 {
5915   tree b = make_node (CPLUS_BINDING);
5916   tree initial = current_decl_namespace();
5917   tree scope = initial;
5918   tree siter;
5919   struct binding_level *level;
5920   tree val = NULL_TREE;
5921
5922   if (spacesp)
5923     *spacesp = NULL_TREE;
5924
5925   for (; !val; scope = CP_DECL_CONTEXT (scope))
5926     {
5927       if (spacesp)
5928         *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5929       val = binding_for_name (name, scope);
5930
5931       /* Initialize binding for this context. */
5932       BINDING_VALUE (b) = BINDING_VALUE (val);
5933       BINDING_TYPE (b) = BINDING_TYPE (val);
5934
5935       /* Add all _DECLs seen through local using-directives. */
5936       for (level = current_binding_level;
5937            !level->namespace_p;
5938            level = level->level_chain)
5939         if (!lookup_using_namespace (name, b, level->using_directives,
5940                                      scope, flags, spacesp))
5941           /* Give up because of error. */
5942           return error_mark_node;
5943
5944       /* Add all _DECLs seen through global using-directives. */
5945       /* XXX local and global using lists should work equally. */
5946       siter = initial;
5947       while (1)
5948         {
5949           if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5950                                        scope, flags, spacesp))
5951             /* Give up because of error. */
5952             return error_mark_node;
5953           if (siter == scope) break;
5954           siter = CP_DECL_CONTEXT (siter);
5955         }
5956
5957       val = select_decl (b, flags);
5958       if (scope == global_namespace)
5959         break;
5960     }
5961   return val;
5962 }
5963
5964 /* Combine prefer_type and namespaces_only into flags.  */
5965
5966 static int
5967 lookup_flags (prefer_type, namespaces_only)
5968   int prefer_type, namespaces_only;
5969 {
5970   if (namespaces_only)
5971     return LOOKUP_PREFER_NAMESPACES;
5972   if (prefer_type > 1)
5973     return LOOKUP_PREFER_TYPES;
5974   if (prefer_type > 0)
5975     return LOOKUP_PREFER_BOTH;
5976   return 0;
5977 }
5978
5979 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5980    ignore it or not.  Subroutine of lookup_name_real.  */
5981
5982 static tree
5983 qualify_lookup (val, flags)
5984      tree val;
5985      int flags;
5986 {
5987   if (val == NULL_TREE)
5988     return val;
5989   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5990     return val;
5991   if ((flags & LOOKUP_PREFER_TYPES)
5992       && (TREE_CODE (val) == TYPE_DECL
5993           || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5994               && DECL_CLASS_TEMPLATE_P (val))))
5995     return val;
5996   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5997     return NULL_TREE;
5998   return val;
5999 }
6000
6001 /* Any other BINDING overrides an implicit TYPENAME.  Warn about
6002    that.  */
6003
6004 static void
6005 warn_about_implicit_typename_lookup (typename, binding)
6006      tree typename;
6007      tree binding;
6008 {
6009   tree subtype = TREE_TYPE (TREE_TYPE (typename));
6010   tree name = DECL_NAME (typename);
6011
6012   if (! (TREE_CODE (binding) == TEMPLATE_DECL
6013          && CLASSTYPE_TEMPLATE_INFO (subtype)
6014          && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
6015       && ! (TREE_CODE (binding) == TYPE_DECL
6016             && same_type_p (TREE_TYPE (binding), subtype)))
6017     {
6018       cp_warning ("lookup of `%D' finds `%#D'",
6019                   name, binding);
6020       cp_warning ("  instead of `%D' from dependent base class",
6021                   typename);
6022       cp_warning ("  (use `typename %T::%D' if that's what you meant)",
6023                   constructor_name (current_class_type), name);
6024     }
6025 }
6026
6027 /* Look up NAME in the current binding level and its superiors in the
6028    namespace of variables, functions and typedefs.  Return a ..._DECL
6029    node of some kind representing its definition if there is only one
6030    such declaration, or return a TREE_LIST with all the overloaded
6031    definitions if there are many, or return 0 if it is undefined.
6032
6033    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
6034    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
6035    If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
6036    Otherwise we prefer non-TYPE_DECLs.
6037
6038    If NONCLASS is non-zero, we don't look for the NAME in class scope,
6039    using IDENTIFIER_CLASS_VALUE.  */
6040
6041 static tree
6042 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
6043      tree name;
6044      int prefer_type, nonclass, namespaces_only;
6045 {
6046   tree t;
6047   tree val = NULL_TREE;
6048   int yylex = 0;
6049   tree from_obj = NULL_TREE;
6050   int flags;
6051   int val_is_implicit_typename = 0;
6052
6053   /* Hack: copy flag set by parser, if set. */
6054   if (only_namespace_names)
6055     namespaces_only = 1;
6056
6057   if (prefer_type == -2)
6058     {
6059       extern int looking_for_typename;
6060       tree type = NULL_TREE;
6061
6062       yylex = 1;
6063       prefer_type = looking_for_typename;
6064
6065       flags = lookup_flags (prefer_type, namespaces_only);
6066       /* If the next thing is '<', class templates are types. */
6067       if (looking_for_template)
6068         flags |= LOOKUP_TEMPLATES_EXPECTED;
6069
6070       /* std:: becomes :: for now.  */
6071       if (got_scope == std_node)
6072         got_scope = void_type_node;
6073
6074       if (got_scope)
6075         type = got_scope;
6076       else if (got_object != error_mark_node)
6077         type = got_object;
6078
6079       if (type)
6080         {
6081           if (type == error_mark_node)
6082             return error_mark_node;
6083           if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
6084             type = TREE_TYPE (type);
6085
6086           if (TYPE_P (type))
6087             type = complete_type (type);
6088
6089           if (TREE_CODE (type) == VOID_TYPE)
6090             type = global_namespace;
6091           if (TREE_CODE (type) == NAMESPACE_DECL)
6092             {
6093               val = make_node (CPLUS_BINDING);
6094               flags |= LOOKUP_COMPLAIN;
6095               if (!qualified_lookup_using_namespace (name, type, val, flags))
6096                 return NULL_TREE;
6097               val = select_decl (val, flags);
6098             }
6099           else if (! IS_AGGR_TYPE (type)
6100                    || TREE_CODE (type) == TEMPLATE_TYPE_PARM
6101                    || TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM
6102                    || TREE_CODE (type) == TYPENAME_TYPE)
6103             /* Someone else will give an error about this if needed.  */
6104             val = NULL_TREE;
6105           else if (type == current_class_type)
6106             val = IDENTIFIER_CLASS_VALUE (name);
6107           else
6108             {
6109               val = lookup_member (type, name, 0, prefer_type);
6110               type_access_control (type, val);
6111
6112               /* Restore the containing TYPENAME_TYPE if we looked
6113                  through it before.  */
6114               if (got_scope && got_scope != type
6115                   && val && TREE_CODE (val) == TYPE_DECL
6116                   && TREE_CODE (TREE_TYPE (val)) == TYPENAME_TYPE)
6117                 TYPE_CONTEXT (TREE_TYPE (val)) = got_scope;
6118             }
6119         }
6120       else
6121         val = NULL_TREE;
6122
6123       if (got_scope)
6124         goto done;
6125       else if (got_object && val)
6126         from_obj = val;
6127     }
6128   else
6129     {
6130       flags = lookup_flags (prefer_type, namespaces_only);
6131       /* If we're not parsing, we need to complain. */
6132       flags |= LOOKUP_COMPLAIN;
6133     }
6134
6135   /* First, look in non-namespace scopes.  */
6136
6137   if (current_class_type == NULL_TREE)
6138     nonclass = 1;
6139
6140   for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
6141     {
6142       tree binding;
6143
6144       if (!LOCAL_BINDING_P (t) && nonclass)
6145         /* We're not looking for class-scoped bindings, so keep going.  */
6146         continue;
6147
6148       /* If this is the kind of thing we're looking for, we're done.  */
6149       if (qualify_lookup (BINDING_VALUE (t), flags))
6150         binding = BINDING_VALUE (t);
6151       else if ((flags & LOOKUP_PREFER_TYPES)
6152                && qualify_lookup (BINDING_TYPE (t), flags))
6153         binding = BINDING_TYPE (t);
6154       else
6155         binding = NULL_TREE;
6156
6157       /* Handle access control on types from enclosing or base classes.  */
6158       if (binding && ! yylex
6159           && BINDING_LEVEL (t) && BINDING_LEVEL (t)->parm_flag == 2)
6160         type_access_control (BINDING_LEVEL (t)->this_class, binding);
6161
6162       if (binding
6163           && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
6164         {
6165           if (val_is_implicit_typename && !yylex)
6166             warn_about_implicit_typename_lookup (val, binding);
6167           val = binding;
6168           val_is_implicit_typename
6169             = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
6170           if (!val_is_implicit_typename)
6171             break;
6172         }
6173     }
6174
6175   /* Now lookup in namespace scopes.  */
6176   if (!val || val_is_implicit_typename)
6177     {
6178       t = unqualified_namespace_lookup (name, flags, 0);
6179       if (t)
6180         {
6181           if (val_is_implicit_typename && !yylex)
6182             warn_about_implicit_typename_lookup (val, t);
6183           val = t;
6184         }
6185     }
6186
6187  done:
6188   if (val)
6189     {
6190       /* This should only warn about types used in qualified-ids.  */
6191       if (from_obj && from_obj != val)
6192         {
6193           if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
6194               && TREE_CODE (val) == TYPE_DECL
6195               && TREE_TYPE (from_obj) != TREE_TYPE (val))
6196             {
6197               cp_pedwarn ("lookup of `%D' in the scope of `%#T' (`%#T')",
6198                           name, got_object, TREE_TYPE (from_obj));
6199               cp_pedwarn ("  does not match lookup in the current scope (`%#T')",
6200                           TREE_TYPE (val));
6201             }
6202
6203           /* We don't change val to from_obj if got_object depends on
6204              template parms because that breaks implicit typename for
6205              destructor calls.  */
6206           if (! uses_template_parms (got_object))
6207             val = from_obj;
6208         }
6209
6210       /* If we have a single function from a using decl, pull it out.  */
6211       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
6212         val = OVL_FUNCTION (val);
6213     }
6214   else if (from_obj)
6215     val = from_obj;
6216
6217   return val;
6218 }
6219
6220 tree
6221 lookup_name_nonclass (name)
6222      tree name;
6223 {
6224   return lookup_name_real (name, 0, 1, 0);
6225 }
6226
6227 tree
6228 lookup_function_nonclass (name, args)
6229      tree name;
6230      tree args;
6231 {
6232   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
6233 }
6234
6235 tree
6236 lookup_name_namespace_only (name)
6237      tree name;
6238 {
6239   /* type-or-namespace, nonclass, namespace_only */
6240   return lookup_name_real (name, 1, 1, 1);
6241 }
6242
6243 tree
6244 lookup_name (name, prefer_type)
6245      tree name;
6246      int prefer_type;
6247 {
6248   return lookup_name_real (name, prefer_type, 0, 0);
6249 }
6250
6251 /* Similar to `lookup_name' but look only in the innermost non-class
6252    binding level.  */
6253
6254 tree
6255 lookup_name_current_level (name)
6256      tree name;
6257 {
6258   struct binding_level *b;
6259   tree t = NULL_TREE;
6260
6261   b = current_binding_level;
6262   while (b->parm_flag == 2)
6263     b = b->level_chain;
6264
6265   if (b->namespace_p)
6266     {
6267       t = IDENTIFIER_NAMESPACE_VALUE (name);
6268
6269       /* extern "C" function() */
6270       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
6271         t = TREE_VALUE (t);
6272     }
6273   else if (IDENTIFIER_BINDING (name)
6274            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
6275     {
6276       while (1)
6277         {
6278           if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
6279             return IDENTIFIER_VALUE (name);
6280
6281           if (b->keep == 2)
6282             b = b->level_chain;
6283           else
6284             break;
6285         }
6286     }
6287
6288   return t;
6289 }
6290
6291 /* Like lookup_name_current_level, but for types.  */
6292
6293 tree
6294 lookup_type_current_level (name)
6295      tree name;
6296 {
6297   register tree t = NULL_TREE;
6298
6299   my_friendly_assert (! current_binding_level->namespace_p, 980716);
6300
6301   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
6302       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
6303     {
6304       struct binding_level *b = current_binding_level;
6305       while (1)
6306         {
6307           if (purpose_member (name, b->type_shadowed))
6308             return REAL_IDENTIFIER_TYPE_VALUE (name);
6309           if (b->keep == 2)
6310             b = b->level_chain;
6311           else
6312             break;
6313         }
6314     }
6315
6316   return t;
6317 }
6318
6319 void
6320 begin_only_namespace_names ()
6321 {
6322   only_namespace_names = 1;
6323 }
6324
6325 void
6326 end_only_namespace_names ()
6327 {
6328   only_namespace_names = 0;
6329 }
6330 \f
6331 /* Push the declarations of builtin types into the namespace.
6332    RID_INDEX is the index of the builtin type
6333    in the array RID_POINTERS.  NAME is the name used when looking
6334    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
6335
6336 static void
6337 record_builtin_type (rid_index, name, type)
6338      enum rid rid_index;
6339      const char *name;
6340      tree type;
6341 {
6342   tree rname = NULL_TREE, tname = NULL_TREE;
6343   tree tdecl = NULL_TREE;
6344
6345   if ((int) rid_index < (int) RID_MAX)
6346     rname = ridpointers[(int) rid_index];
6347   if (name)
6348     tname = get_identifier (name);
6349
6350   TYPE_BUILT_IN (type) = 1;
6351
6352   if (tname)
6353     {
6354       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
6355       set_identifier_type_value (tname, NULL_TREE);
6356       if ((int) rid_index < (int) RID_MAX)
6357         /* Built-in types live in the global namespace. */
6358         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
6359     }
6360   if (rname != NULL_TREE)
6361     {
6362       if (tname != NULL_TREE)
6363         {
6364           set_identifier_type_value (rname, NULL_TREE);
6365           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
6366         }
6367       else
6368         {
6369           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
6370           set_identifier_type_value (rname, NULL_TREE);
6371         }
6372     }
6373 }
6374
6375 /* Record one of the standard Java types.
6376  * Declare it as having the given NAME.
6377  * If SIZE > 0, it is the size of one of the integral types;
6378  * otherwise it is the negative of the size of one of the other types.  */
6379
6380 static tree
6381 record_builtin_java_type (name, size)
6382      const char *name;
6383      int size;
6384 {
6385   tree type, decl;
6386   if (size > 0)
6387     type = make_signed_type (size);
6388   else if (size > -32)
6389     { /* "__java_char" or ""__java_boolean". */
6390       type = make_unsigned_type (-size);
6391       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6392     }
6393   else
6394     { /* "__java_float" or ""__java_double". */
6395       type = make_node (REAL_TYPE);
6396       TYPE_PRECISION (type) = - size;
6397       layout_type (type);
6398     }
6399   record_builtin_type (RID_MAX, name, type);
6400   decl = TYPE_NAME (type);
6401
6402   /* Suppress generate debug symbol entries for these types,
6403      since for normal C++ they are just clutter.
6404      However, push_lang_context undoes this if extern "Java" is seen. */
6405   DECL_IGNORED_P (decl) = 1;
6406
6407   TYPE_FOR_JAVA (type) = 1;
6408   return type;
6409 }
6410
6411 /* Push a type into the namespace so that the back-ends ignore it. */
6412
6413 static void
6414 record_unknown_type (type, name)
6415      tree type;
6416      const char *name;
6417 {
6418   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
6419   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
6420   DECL_IGNORED_P (decl) = 1;
6421   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6422   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
6423   TYPE_ALIGN (type) = 1;
6424   TYPE_USER_ALIGN (type) = 0;
6425   TYPE_MODE (type) = TYPE_MODE (void_type_node);
6426 }
6427
6428 /* An string for which we should create an IDENTIFIER_NODE at
6429    startup.  */
6430
6431 typedef struct predefined_identifier
6432 {
6433   /* The name of the identifier.  */
6434   const char *name;
6435   /* The place where the IDENTIFIER_NODE should be stored.  */
6436   tree *node;
6437   /* Non-zero if this is the name of a constructor or destructor.  */
6438   int ctor_or_dtor_p;
6439 } predefined_identifier;
6440
6441 /* Create all the predefined identifiers.  */
6442
6443 static void
6444 initialize_predefined_identifiers ()
6445 {
6446   struct predefined_identifier *pid;
6447
6448   /* A table of identifiers to create at startup.  */
6449   static predefined_identifier predefined_identifiers[] = {
6450     { "C++", &lang_name_cplusplus, 0 },
6451     { "C", &lang_name_c, 0 },
6452     { "Java", &lang_name_java, 0 },
6453     { CTOR_NAME, &ctor_identifier, 1 },
6454     { "__base_ctor", &base_ctor_identifier, 1 },
6455     { "__comp_ctor", &complete_ctor_identifier, 1 },
6456     { DTOR_NAME, &dtor_identifier, 1 },
6457     { "__comp_dtor", &complete_dtor_identifier, 1 },
6458     { "__base_dtor", &base_dtor_identifier, 1 },
6459     { "__deleting_dtor", &deleting_dtor_identifier, 1 },
6460     { VTABLE_DELTA2_NAME, &delta2_identifier, 0 },
6461     { VTABLE_DELTA_NAME, &delta_identifier, 0 },
6462     { IN_CHARGE_NAME, &in_charge_identifier, 0 },
6463     { VTABLE_INDEX_NAME, &index_identifier, 0 },
6464     { "nelts", &nelts_identifier, 0 },
6465     { THIS_NAME, &this_identifier, 0 },
6466     { VTABLE_PFN_NAME, &pfn_identifier, 0 },
6467     { "__pfn_or_delta2", &pfn_or_delta2_identifier, 0 },
6468     { "_vptr", &vptr_identifier, 0 },
6469     { "__cp_push_exception", &cp_push_exception_identifier, 0 },
6470     { "__vtt_parm", &vtt_parm_identifier, 0 },
6471     { "std", &std_identifier, 0 },
6472     { NULL, NULL, 0 }
6473   };
6474
6475   for (pid = predefined_identifiers; pid->name; ++pid)
6476     {
6477       *pid->node = get_identifier (pid->name);
6478       if (pid->ctor_or_dtor_p)
6479         IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
6480     }
6481 }
6482
6483 /* Create the predefined scalar types of C,
6484    and some nodes representing standard constants (0, 1, (void *)0).
6485    Initialize the global binding level.
6486    Make definitions for built-in primitive functions.  */
6487
6488 void
6489 init_decl_processing ()
6490 {
6491   tree fields[20];
6492   int wchar_type_size;
6493   tree array_domain_type;
6494
6495   /* Check to see that the user did not specify an invalid combination
6496      of command-line options.  */
6497   if (flag_new_abi && !flag_vtable_thunks)
6498     fatal ("the new ABI requires vtable thunks");
6499
6500   /* Create all the identifiers we need.  */
6501   initialize_predefined_identifiers ();
6502
6503   /* Let the back-end now how to save and restore language-specific
6504      per-function globals.  */
6505   init_lang_status = &push_cp_function_context;
6506   free_lang_status = &pop_cp_function_context;
6507   mark_lang_status = &mark_cp_function_context;
6508
6509   cp_parse_init ();
6510   init_decl2 ();
6511   init_pt ();
6512
6513   /* Create the global variables.  */
6514   push_to_top_level ();
6515
6516   /* Enter the global namespace. */
6517   my_friendly_assert (global_namespace == NULL_TREE, 375);
6518   push_namespace (get_identifier ("::"));
6519   global_namespace = current_namespace;
6520   current_lang_name = NULL_TREE;
6521
6522   /* Adjust various flags based on command-line settings.  */
6523   if (! flag_permissive && ! pedantic)
6524     flag_pedantic_errors = 1;
6525   if (!flag_no_inline)
6526     flag_inline_trees = 1;
6527
6528   /* Initially, C.  */
6529   current_lang_name = lang_name_c;
6530
6531   current_function_decl = NULL_TREE;
6532   current_binding_level = NULL_BINDING_LEVEL;
6533   free_binding_level = NULL_BINDING_LEVEL;
6534
6535   build_common_tree_nodes (flag_signed_char);
6536
6537   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6538   TREE_TYPE (error_mark_list) = error_mark_node;
6539
6540   /* Make the binding_level structure for global names.  */
6541   pushlevel (0);
6542   global_binding_level = current_binding_level;
6543   /* The global level is the namespace level of ::.  */
6544   NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6545   declare_namespace_level ();
6546
6547   /* Define `int' and `char' first so that dbx will output them first.  */
6548   record_builtin_type (RID_INT, NULL_PTR, integer_type_node);
6549   record_builtin_type (RID_CHAR, "char", char_type_node);
6550
6551   /* `signed' is the same as `int' */
6552   record_builtin_type (RID_SIGNED, NULL_PTR, integer_type_node);
6553   record_builtin_type (RID_LONG, "long int", long_integer_type_node);
6554   record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
6555   record_builtin_type (RID_MAX, "long unsigned int",
6556                        long_unsigned_type_node);
6557   record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
6558   record_builtin_type (RID_MAX, "long long int",
6559                        long_long_integer_type_node);
6560   record_builtin_type (RID_MAX, "long long unsigned int",
6561                        long_long_unsigned_type_node);
6562   record_builtin_type (RID_MAX, "long long unsigned",
6563                        long_long_unsigned_type_node);
6564   record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
6565   record_builtin_type (RID_MAX, "short unsigned int",
6566                        short_unsigned_type_node);
6567   record_builtin_type (RID_MAX, "unsigned short",
6568                        short_unsigned_type_node);
6569
6570   ptrdiff_type_node
6571     = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE)));
6572
6573   /* Define both `signed char' and `unsigned char'.  */
6574   record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
6575   record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
6576
6577   /* `unsigned long' is the standard type for sizeof.
6578      Note that stddef.h uses `unsigned long',
6579      and this must agree, even if long and int are the same size.  */
6580   set_sizetype
6581     (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE))));
6582
6583   /* Create the widest literal types. */
6584   widest_integer_literal_type_node = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
6585   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6586                         widest_integer_literal_type_node));
6587
6588   widest_unsigned_literal_type_node = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
6589   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6590                         widest_unsigned_literal_type_node));
6591
6592   /* These are types that type_for_size and type_for_mode use.  */
6593   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
6594   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
6595   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
6596   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
6597 #if HOST_BITS_PER_WIDE_INT >= 64
6598   pushdecl (build_decl (TYPE_DECL, get_identifier ("__int128_t"), intTI_type_node));
6599 #endif
6600   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
6601   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
6602   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
6603   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
6604 #if HOST_BITS_PER_WIDE_INT >= 64
6605   pushdecl (build_decl (TYPE_DECL, get_identifier ("__uint128_t"), unsigned_intTI_type_node));
6606 #endif
6607
6608   build_common_tree_nodes_2 (flag_short_double);
6609
6610   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6611   java_short_type_node = record_builtin_java_type ("__java_short", 16);
6612   java_int_type_node = record_builtin_java_type ("__java_int", 32);
6613   java_long_type_node = record_builtin_java_type ("__java_long", 64);
6614   java_float_type_node = record_builtin_java_type ("__java_float", -32);
6615   java_double_type_node = record_builtin_java_type ("__java_double", -64);
6616   java_char_type_node = record_builtin_java_type ("__java_char", -16);
6617   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6618
6619   integer_two_node = build_int_2 (2, 0);
6620   TREE_TYPE (integer_two_node) = integer_type_node;
6621   integer_three_node = build_int_2 (3, 0);
6622   TREE_TYPE (integer_three_node) = integer_type_node;
6623
6624   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6625   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6626   TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6627   TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6628   TYPE_PRECISION (boolean_type_node) = 1;
6629   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6630   boolean_false_node = build_int_2 (0, 0);
6631   TREE_TYPE (boolean_false_node) = boolean_type_node;
6632   boolean_true_node = build_int_2 (1, 0);
6633   TREE_TYPE (boolean_true_node) = boolean_type_node;
6634
6635   signed_size_zero_node = build_int_2 (0, 0);
6636   record_builtin_type (RID_FLOAT, NULL_PTR, float_type_node);
6637   record_builtin_type (RID_DOUBLE, NULL_PTR, double_type_node);
6638   record_builtin_type (RID_MAX, "long double", long_double_type_node);
6639
6640   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
6641                         complex_integer_type_node));
6642   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
6643                         complex_float_type_node));
6644   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),
6645                         complex_double_type_node));
6646   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
6647                         complex_long_double_type_node));
6648
6649   TREE_TYPE (signed_size_zero_node) = make_signed_type (TYPE_PRECISION (sizetype));
6650
6651   record_builtin_type (RID_VOID, NULL_PTR, void_type_node);
6652   void_list_node = build_tree_list (NULL_TREE, void_type_node);
6653   TREE_PARMLIST (void_list_node) = 1;
6654
6655   string_type_node = build_pointer_type (char_type_node);
6656   const_string_type_node
6657     = build_pointer_type (build_qualified_type (char_type_node,
6658                                                 TYPE_QUAL_CONST));
6659   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6660 #if 0
6661   record_builtin_type (RID_MAX, NULL_PTR, string_type_node);
6662 #endif
6663
6664   /* Make a type to be the domain of a few array types
6665      whose domains don't really matter.
6666      200 is small enough that it always fits in size_t.  */
6667   array_domain_type = build_index_type (build_int_2 (200, 0));
6668
6669   /* Make a type for arrays of characters.
6670      With luck nothing will ever really depend on the length of this
6671      array type.  */
6672   char_array_type_node
6673     = build_array_type (char_type_node, array_domain_type);
6674
6675   /* Likewise for arrays of ints.  */
6676   int_array_type_node
6677     = build_array_type (integer_type_node, array_domain_type);
6678
6679   if (flag_new_abi)
6680     delta_type_node = ptrdiff_type_node;
6681   else if (flag_huge_objects)
6682     delta_type_node = long_integer_type_node;
6683   else
6684     delta_type_node = short_integer_type_node;
6685
6686   if (flag_new_abi)
6687     vtable_index_type = ptrdiff_type_node;
6688   else
6689     vtable_index_type = delta_type_node;
6690
6691   default_function_type
6692     = build_function_type (integer_type_node, NULL_TREE);
6693
6694   ptr_type_node = build_pointer_type (void_type_node);
6695   const_ptr_type_node
6696     = build_pointer_type (build_qualified_type (void_type_node,
6697                                                 TYPE_QUAL_CONST));
6698   vtt_parm_type = build_pointer_type (const_ptr_type_node);
6699   c_common_nodes_and_builtins (1, flag_no_builtin, flag_no_nonansi_builtin);
6700   lang_type_promotes_to = convert_type_from_ellipsis;
6701
6702   void_ftype_ptr
6703     = build_exception_variant (void_ftype_ptr, empty_except_spec);
6704
6705   /* C++ extensions */
6706
6707   unknown_type_node = make_node (UNKNOWN_TYPE);
6708   record_unknown_type (unknown_type_node, "unknown type");
6709
6710   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
6711   TREE_TYPE (unknown_type_node) = unknown_type_node;
6712
6713   TREE_TYPE (null_node) = type_for_size (POINTER_SIZE, 0);
6714
6715   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6716      result.  */
6717   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6718   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6719
6720   /* This is special for C++ so functions can be overloaded.  */
6721   wchar_type_node = get_identifier (flag_short_wchar
6722                                     ? "short unsigned int"
6723                                     : WCHAR_TYPE);
6724   wchar_type_node = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (wchar_type_node));
6725   wchar_type_size = TYPE_PRECISION (wchar_type_node);
6726   if (TREE_UNSIGNED (wchar_type_node))
6727     wchar_type_node = make_signed_type (wchar_type_size);
6728   else
6729     wchar_type_node = make_unsigned_type (wchar_type_size);
6730   record_builtin_type (RID_WCHAR, "__wchar_t", wchar_type_node);
6731
6732   /* Artificial declaration of wchar_t -- can be bashed */
6733   wchar_decl_node = build_decl (TYPE_DECL, get_identifier ("wchar_t"),
6734                                 wchar_type_node);
6735   pushdecl (wchar_decl_node);
6736
6737   /* This is for wide string constants.  */
6738   wchar_array_type_node
6739     = build_array_type (wchar_type_node, array_domain_type);
6740
6741   if (flag_vtable_thunks)
6742     {
6743       /* Make sure we get a unique function type, so we can give
6744          its pointer type a name.  (This wins for gdb.) */
6745       tree vfunc_type = make_node (FUNCTION_TYPE);
6746       TREE_TYPE (vfunc_type) = integer_type_node;
6747       TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6748       layout_type (vfunc_type);
6749
6750       vtable_entry_type = build_pointer_type (vfunc_type);
6751     }
6752   else
6753     {
6754       vtable_entry_type = make_aggr_type (RECORD_TYPE);
6755       fields[0] = build_decl (FIELD_DECL, delta_identifier,
6756                               delta_type_node);
6757       fields[1] = build_decl (FIELD_DECL, index_identifier,
6758                               delta_type_node);
6759       fields[2] = build_decl (FIELD_DECL, pfn_identifier,
6760                               ptr_type_node);
6761       finish_builtin_type (vtable_entry_type, VTBL_PTR_TYPE, fields, 2,
6762                            double_type_node);
6763
6764       /* Make this part of an invisible union.  */
6765       fields[3] = copy_node (fields[2]);
6766       TREE_TYPE (fields[3]) = delta_type_node;
6767       DECL_NAME (fields[3]) = delta2_identifier;
6768       DECL_MODE (fields[3]) = TYPE_MODE (delta_type_node);
6769       DECL_SIZE (fields[3]) = TYPE_SIZE (delta_type_node);
6770       DECL_SIZE_UNIT (fields[3]) = TYPE_SIZE_UNIT (delta_type_node);
6771       TREE_UNSIGNED (fields[3]) = 0;
6772       TREE_CHAIN (fields[2]) = fields[3];
6773       vtable_entry_type = build_qualified_type (vtable_entry_type,
6774                                                 TYPE_QUAL_CONST);
6775     }
6776   record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6777
6778   vtbl_type_node
6779     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6780   layout_type (vtbl_type_node);
6781   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6782   record_builtin_type (RID_MAX, NULL_PTR, vtbl_type_node);
6783   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6784   layout_type (vtbl_ptr_type_node);
6785   record_builtin_type (RID_MAX, NULL_PTR, vtbl_ptr_type_node);
6786
6787   std_node = build_decl (NAMESPACE_DECL,
6788                          flag_honor_std
6789                          ? get_identifier ("fake std") : std_identifier,
6790                          void_type_node);
6791   pushdecl (std_node);
6792
6793   if (flag_new_abi)
6794     {
6795       push_namespace (get_identifier ("__cxxabiv1"));
6796       abi_node = current_namespace;
6797       pop_namespace ();
6798     }
6799
6800   global_type_node = make_node (LANG_TYPE);
6801   record_unknown_type (global_type_node, "global type");
6802
6803   /* Now, C++.  */
6804   current_lang_name = lang_name_cplusplus;
6805
6806   {
6807     tree bad_alloc_type_node, newtype, deltype;
6808     if (flag_honor_std)
6809       push_namespace (get_identifier ("std"));
6810     bad_alloc_type_node = xref_tag
6811       (class_type_node, get_identifier ("bad_alloc"), 1);
6812     if (flag_honor_std)
6813       pop_namespace ();
6814     newtype = build_exception_variant
6815       (ptr_ftype_sizetype, add_exception_specifier (NULL_TREE, bad_alloc_type_node, -1));
6816     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6817     push_cp_library_fn (NEW_EXPR, newtype);
6818     push_cp_library_fn (VEC_NEW_EXPR, newtype);
6819     global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
6820     push_cp_library_fn (VEC_DELETE_EXPR, deltype);
6821   }
6822
6823   abort_fndecl
6824     = build_library_fn_ptr ("__pure_virtual", void_ftype);
6825
6826   /* Perform other language dependent initializations.  */
6827   init_class_processing ();
6828   init_init_processing ();
6829   init_search_processing ();
6830   init_rtti_processing ();
6831
6832   if (flag_exceptions)
6833     init_exception_processing ();
6834   if (flag_no_inline)
6835     {
6836       flag_inline_functions = 0;
6837     }
6838
6839   if (! supports_one_only ())
6840     flag_weak = 0;
6841
6842   /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__.  */
6843   function_id_node = get_identifier ("__FUNCTION__");
6844   pretty_function_id_node = get_identifier ("__PRETTY_FUNCTION__");
6845   func_id_node = get_identifier ("__func__");
6846
6847   make_fname_decl = cp_make_fname_decl;
6848   declare_function_name ();
6849
6850   /* Prepare to check format strings against argument lists.  */
6851   init_function_format_info ();
6852
6853   /* Show we use EH for cleanups.  */
6854   using_eh_for_cleanups ();
6855
6856   valid_lang_attribute = cp_valid_lang_attribute;
6857
6858   /* Maintain consistency.  Perhaps we should just complain if they
6859      say -fwritable-strings?  */
6860   if (flag_writable_strings)
6861     flag_const_strings = 0;
6862
6863   /* Add GC roots for all of our global variables.  */
6864   ggc_add_tree_root (c_global_trees, sizeof c_global_trees / sizeof(tree));
6865   ggc_add_tree_root (cp_global_trees, sizeof cp_global_trees / sizeof(tree));
6866   ggc_add_tree_root (&integer_three_node, 1);
6867   ggc_add_tree_root (&integer_two_node, 1);
6868   ggc_add_tree_root (&signed_size_zero_node, 1);
6869   ggc_add_tree_root (&size_one_node, 1);
6870   ggc_add_tree_root (&size_zero_node, 1);
6871   ggc_add_root (&global_binding_level, 1, sizeof global_binding_level,
6872                 mark_binding_level);
6873   ggc_add_root (&scope_chain, 1, sizeof scope_chain, &mark_saved_scope);
6874   ggc_add_tree_root (&static_ctors, 1);
6875   ggc_add_tree_root (&static_dtors, 1);
6876   ggc_add_tree_root (&lastiddecl, 1);
6877
6878   ggc_add_tree_root (&last_function_parm_tags, 1);
6879   ggc_add_tree_root (&current_function_return_value, 1);
6880   ggc_add_tree_root (&current_function_parms, 1);
6881   ggc_add_tree_root (&current_function_parm_tags, 1);
6882   ggc_add_tree_root (&last_function_parms, 1);
6883   ggc_add_tree_root (&error_mark_list, 1);
6884
6885   ggc_add_tree_root (&global_namespace, 1);
6886   ggc_add_tree_root (&global_type_node, 1);
6887   ggc_add_tree_root (&anonymous_namespace_name, 1);
6888
6889   ggc_add_tree_root (&got_object, 1);
6890   ggc_add_tree_root (&got_scope, 1);
6891
6892   ggc_add_tree_root (&current_lang_name, 1);
6893   ggc_add_tree_root (&static_aggregates, 1);
6894 }
6895
6896 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6897    decl, NAME is the initialization string and TYPE_DEP indicates whether
6898    NAME depended on the type of the function. We make use of that to detect
6899    __PRETTY_FUNCTION__ inside a template fn.  Because we build a tree for
6900    the function before emitting any of it, we don't need to treat the
6901    VAR_DECL specially. We can decide whether to emit it later, if it was
6902    used.  */
6903
6904 static tree
6905 cp_make_fname_decl (id, name, type_dep)
6906      tree id;
6907      const char *name;
6908      int type_dep;
6909 {
6910   tree decl, type, init;
6911   size_t length = strlen (name);
6912   tree domain = NULL_TREE;
6913
6914   if (!processing_template_decl)
6915     type_dep = 0;
6916   if (!type_dep)
6917     domain = build_index_type (build_int_2 (length, 0));
6918
6919   type =  build_cplus_array_type
6920           (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
6921            domain);
6922
6923   decl = build_decl (VAR_DECL, id, type);
6924   TREE_STATIC (decl) = 1;
6925   TREE_READONLY (decl) = 1;
6926   DECL_SOURCE_LINE (decl) = 0;
6927   DECL_ARTIFICIAL (decl) = 1;
6928   DECL_IN_SYSTEM_HEADER (decl) = 1;
6929   pushdecl (decl);
6930   if (processing_template_decl)
6931     decl = push_template_decl (decl);
6932   if (type_dep)
6933     {
6934       init = build (FUNCTION_NAME, type);
6935       DECL_PRETTY_FUNCTION_P (decl) = 1;
6936     }
6937   else
6938     {
6939       init = build_string (length + 1, name);
6940       TREE_TYPE (init) = type;
6941     }
6942   DECL_INITIAL (decl) = init;
6943   cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
6944
6945   /* We will have to make sure we only emit this, if it is actually used. */
6946   return decl;
6947 }
6948
6949 /* Entry point for the benefit of c_common_nodes_and_builtins.
6950
6951    Make a definition for a builtin function named NAME and whose data type
6952    is TYPE.  TYPE should be a function type with argument types.
6953
6954    CLASS and CODE tell later passes how to compile calls to this function.
6955    See tree.h for possible values.
6956
6957    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6958    the name to be called if we can't opencode the function.  */
6959
6960 tree
6961 builtin_function (name, type, code, class, libname)
6962      const char *name;
6963      tree type;
6964      int code;
6965      enum built_in_class class;
6966      const char *libname;
6967 {
6968   tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
6969   DECL_BUILT_IN_CLASS (decl) = class;
6970   DECL_FUNCTION_CODE (decl) = code;
6971
6972   my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 392);
6973
6974   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6975      we cannot change DECL_ASSEMBLER_NAME until we have installed this
6976      function in the namespace.  */
6977   pushdecl (decl);
6978   if (libname)
6979     DECL_ASSEMBLER_NAME (decl) = get_identifier (libname);
6980   make_function_rtl (decl);
6981
6982   /* Warn if a function in the namespace for users
6983      is used without an occasion to consider it declared.  */
6984   if (name[0] != '_' || name[1] != '_')
6985     DECL_ANTICIPATED (decl) = 1;
6986
6987   return decl;
6988 }
6989
6990 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
6991    function.  Not called directly.  */
6992
6993 static tree
6994 build_library_fn_1 (name, operator_code, type)
6995      tree name;
6996      enum tree_code operator_code;
6997      tree type;
6998 {
6999   tree fn = build_lang_decl (FUNCTION_DECL, name, type);
7000   DECL_EXTERNAL (fn) = 1;
7001   TREE_PUBLIC (fn) = 1;
7002   DECL_ARTIFICIAL (fn) = 1;
7003   TREE_NOTHROW (fn) = 1;
7004   SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
7005   return fn;
7006 }
7007
7008 /* Returns the _DECL for a library function with C linkage.
7009    We assume that such functions never throw; if this is incorrect,
7010    callers should unset TREE_NOTHROW.  */
7011
7012 tree
7013 build_library_fn (name, type)
7014      tree name;
7015      tree type;
7016 {
7017   tree fn = build_library_fn_1 (name, ERROR_MARK, type);
7018   make_function_rtl (fn);
7019   return fn;
7020 }
7021
7022 /* Returns the _DECL for a library function with C++ linkage.  */
7023
7024 static tree
7025 build_cp_library_fn (name, operator_code, type)
7026      tree name;
7027      enum tree_code operator_code;
7028      tree type;
7029 {
7030   tree fn = build_library_fn_1 (name, operator_code, type);
7031   TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
7032   DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
7033   set_mangled_name_for_decl (fn);
7034   make_function_rtl (fn);
7035   return fn;
7036 }
7037
7038 /* Like build_library_fn, but takes a C string instead of an
7039    IDENTIFIER_NODE.  */
7040
7041 tree
7042 build_library_fn_ptr (name, type)
7043      const char *name;
7044      tree type;
7045 {
7046   return build_library_fn (get_identifier (name), type);
7047 }
7048
7049 /* Like build_cp_library_fn, but takes a C string instead of an
7050    IDENTIFIER_NODE.  */
7051
7052 tree
7053 build_cp_library_fn_ptr (name, type)
7054      const char *name;
7055      tree type;
7056 {
7057   return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
7058 }
7059
7060 /* Like build_library_fn, but also pushes the function so that we will
7061    be able to find it via IDENTIFIER_GLOBAL_VALUE.  */
7062
7063 tree
7064 push_library_fn (name, type)
7065      tree name, type;
7066 {
7067   tree fn = build_library_fn (name, type);
7068   pushdecl_top_level (fn);
7069   return fn;
7070 }
7071
7072 /* Like build_cp_library_fn, but also pushes the function so that it
7073    will be found by normal lookup.  */
7074
7075 static tree
7076 push_cp_library_fn (operator_code, type)
7077      enum tree_code operator_code;
7078      tree type;
7079 {
7080   tree fn = build_cp_library_fn (ansi_opname (operator_code),
7081                                  operator_code,
7082                                  type);
7083   pushdecl (fn);
7084   return fn;
7085 }
7086
7087 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
7088    a FUNCTION_TYPE.  */
7089
7090 tree
7091 push_void_library_fn (name, parmtypes)
7092      tree name, parmtypes;
7093 {
7094   tree type = build_function_type (void_type_node, parmtypes);
7095   return push_library_fn (name, type);
7096 }
7097
7098 /* Like push_library_fn, but also note that this function throws
7099    and does not return.  Used for __throw_foo and the like.  */
7100
7101 tree
7102 push_throw_library_fn (name, type)
7103      tree name, type;
7104 {
7105   tree fn = push_library_fn (name, type);
7106   TREE_THIS_VOLATILE (fn) = 1;
7107   TREE_NOTHROW (fn) = 0;
7108   return fn;
7109 }
7110 \f
7111 /* When we call finish_struct for an anonymous union, we create
7112    default copy constructors and such.  But, an anonymous union
7113    shouldn't have such things; this function undoes the damage to the
7114    anonymous union type T.
7115
7116    (The reason that we create the synthesized methods is that we don't
7117    distinguish `union { int i; }' from `typedef union { int i; } U'.
7118    The first is an anonymous union; the second is just an ordinary
7119    union type.)  */
7120
7121 void
7122 fixup_anonymous_aggr (t)
7123      tree t;
7124 {
7125   tree *q;
7126
7127   /* Wipe out memory of synthesized methods */
7128   TYPE_HAS_CONSTRUCTOR (t) = 0;
7129   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
7130   TYPE_HAS_INIT_REF (t) = 0;
7131   TYPE_HAS_CONST_INIT_REF (t) = 0;
7132   TYPE_HAS_ASSIGN_REF (t) = 0;
7133   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
7134
7135   /* Splice the implicitly generated functions out of the TYPE_METHODS
7136      list.  */
7137   q = &TYPE_METHODS (t);
7138   while (*q)
7139     {
7140       if (DECL_ARTIFICIAL (*q))
7141         *q = TREE_CHAIN (*q);
7142       else
7143         q = &TREE_CHAIN (*q);
7144     }
7145
7146   /* ISO C++ 9.5.3.  Anonymous unions may not have function members.  */
7147   if (TYPE_METHODS (t))
7148     error ("an anonymous union cannot have function members");
7149 }
7150
7151 /* Make sure that a declaration with no declarator is well-formed, i.e.
7152    just defines a tagged type or anonymous union.
7153
7154    Returns the type defined, if any.  */
7155
7156 tree
7157 check_tag_decl (declspecs)
7158      tree declspecs;
7159 {
7160   int found_type = 0;
7161   int saw_friend = 0;
7162   tree ob_modifier = NULL_TREE;
7163   register tree link;
7164   register tree t = NULL_TREE;
7165
7166   for (link = declspecs; link; link = TREE_CHAIN (link))
7167     {
7168       register tree value = TREE_VALUE (link);
7169
7170       if (TYPE_P (value)
7171           || (TREE_CODE (value) == IDENTIFIER_NODE
7172               && IDENTIFIER_GLOBAL_VALUE (value)
7173               && TYPE_P (IDENTIFIER_GLOBAL_VALUE (value))))
7174         {
7175           ++found_type;
7176
7177           if ((TREE_CODE (value) != TYPENAME_TYPE && IS_AGGR_TYPE (value))
7178               || TREE_CODE (value) == ENUMERAL_TYPE)
7179             {
7180               my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
7181               t = value;
7182             }
7183         }
7184       else if (value == ridpointers[(int) RID_FRIEND])
7185         {
7186           if (current_class_type == NULL_TREE
7187               || current_scope () != current_class_type)
7188             ob_modifier = value;
7189           else
7190             saw_friend = 1;
7191         }
7192       else if (value == ridpointers[(int) RID_STATIC]
7193                || value == ridpointers[(int) RID_EXTERN]
7194                || value == ridpointers[(int) RID_AUTO]
7195                || value == ridpointers[(int) RID_REGISTER]
7196                || value == ridpointers[(int) RID_INLINE]
7197                || value == ridpointers[(int) RID_VIRTUAL]
7198                || value == ridpointers[(int) RID_CONST]
7199                || value == ridpointers[(int) RID_VOLATILE]
7200                || value == ridpointers[(int) RID_EXPLICIT])
7201         ob_modifier = value;
7202     }
7203
7204   if (found_type > 1)
7205     error ("multiple types in one declaration");
7206
7207   if (t == NULL_TREE && ! saw_friend)
7208     pedwarn ("declaration does not declare anything");
7209
7210   /* Check for an anonymous union.  We're careful
7211      accessing TYPE_IDENTIFIER because some built-in types, like
7212      pointer-to-member types, do not have TYPE_NAME.  */
7213   else if (t && IS_AGGR_TYPE_CODE (TREE_CODE (t))
7214            && TYPE_NAME (t)
7215            && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
7216     {
7217       /* Anonymous unions are objects, so they can have specifiers.  */;
7218       SET_ANON_AGGR_TYPE_P (t);
7219
7220       if (TREE_CODE (t) != UNION_TYPE && pedantic && ! in_system_header)
7221         pedwarn ("ISO C++ prohibits anonymous structs");
7222     }
7223
7224   else if (ob_modifier)
7225     {
7226       if (ob_modifier == ridpointers[(int) RID_INLINE]
7227           || ob_modifier == ridpointers[(int) RID_VIRTUAL])
7228         cp_error ("`%D' can only be specified for functions", ob_modifier);
7229       else if (ob_modifier == ridpointers[(int) RID_FRIEND])
7230         cp_error ("`%D' can only be specified inside a class", ob_modifier);
7231       else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
7232         cp_error ("`%D' can only be specified for constructors",
7233                   ob_modifier);
7234       else
7235         cp_error ("`%D' can only be specified for objects and functions",
7236                   ob_modifier);
7237     }
7238
7239   return t;
7240 }
7241
7242 /* Called when a declaration is seen that contains no names to declare.
7243    If its type is a reference to a structure, union or enum inherited
7244    from a containing scope, shadow that tag name for the current scope
7245    with a forward reference.
7246    If its type defines a new named structure or union
7247    or defines an enum, it is valid but we need not do anything here.
7248    Otherwise, it is an error.
7249
7250    C++: may have to grok the declspecs to learn about static,
7251    complain for anonymous unions.  */
7252
7253 void
7254 shadow_tag (declspecs)
7255      tree declspecs;
7256 {
7257   tree t = check_tag_decl (declspecs);
7258
7259   if (t)
7260     maybe_process_partial_specialization (t);
7261
7262   /* This is where the variables in an anonymous union are
7263      declared.  An anonymous union declaration looks like:
7264      union { ... } ;
7265      because there is no declarator after the union, the parser
7266      sends that declaration here.  */
7267   if (t && ANON_AGGR_TYPE_P (t))
7268     {
7269       fixup_anonymous_aggr (t);
7270
7271       if (TYPE_FIELDS (t))
7272         {
7273           tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
7274                                       NULL_TREE);
7275           finish_anon_union (decl);
7276         }
7277     }
7278 }
7279 \f
7280 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
7281
7282 tree
7283 groktypename (typename)
7284      tree typename;
7285 {
7286   if (TREE_CODE (typename) != TREE_LIST)
7287     return typename;
7288   return grokdeclarator (TREE_VALUE (typename),
7289                          TREE_PURPOSE (typename),
7290                          TYPENAME, 0, NULL_TREE);
7291 }
7292
7293 /* Decode a declarator in an ordinary declaration or data definition.
7294    This is called as soon as the type information and variable name
7295    have been parsed, before parsing the initializer if any.
7296    Here we create the ..._DECL node, fill in its type,
7297    and put it on the list of decls for the current context.
7298    The ..._DECL node is returned as the value.
7299
7300    Exception: for arrays where the length is not specified,
7301    the type is left null, to be filled in by `cp_finish_decl'.
7302
7303    Function definitions do not come here; they go to start_function
7304    instead.  However, external and forward declarations of functions
7305    do go through here.  Structure field declarations are done by
7306    grokfield and not through here.  */
7307
7308 tree
7309 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
7310      tree declarator, declspecs;
7311      int initialized;
7312      tree attributes, prefix_attributes;
7313 {
7314   register tree decl;
7315   register tree type, tem;
7316   tree context;
7317   extern int have_extern_spec;
7318   extern int used_extern_spec;
7319   tree attrlist;
7320
7321 #if 0
7322   /* See code below that used this.  */
7323   int init_written = initialized;
7324 #endif
7325
7326   /* This should only be done once on the top most decl.  */
7327   if (have_extern_spec && !used_extern_spec)
7328     {
7329       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"),
7330                                   declspecs);
7331       used_extern_spec = 1;
7332     }
7333
7334   if (attributes || prefix_attributes)
7335     attrlist = build_tree_list (attributes, prefix_attributes);
7336   else
7337     attrlist = NULL_TREE;
7338
7339   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
7340                          attrlist);
7341
7342   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
7343     return NULL_TREE;
7344
7345   type = TREE_TYPE (decl);
7346
7347   if (type == error_mark_node)
7348     return NULL_TREE;
7349
7350   context = DECL_CONTEXT (decl);
7351
7352   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
7353       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
7354     {
7355       /* When parsing the initializer, lookup should use the object's
7356          namespace. */
7357       push_decl_namespace (context);
7358     }
7359
7360   /* We are only interested in class contexts, later. */
7361   if (context && TREE_CODE (context) == NAMESPACE_DECL)
7362     context = NULL_TREE;
7363
7364   if (initialized)
7365     /* Is it valid for this decl to have an initializer at all?
7366        If not, set INITIALIZED to zero, which will indirectly
7367        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7368     switch (TREE_CODE (decl))
7369       {
7370       case TYPE_DECL:
7371         /* typedef foo = bar  means give foo the same type as bar.
7372            We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
7373            Any other case of an initialization in a TYPE_DECL is an error.  */
7374         if (pedantic || list_length (declspecs) > 1)
7375           {
7376             cp_error ("typedef `%D' is initialized", decl);
7377             initialized = 0;
7378           }
7379         break;
7380
7381       case FUNCTION_DECL:
7382         cp_error ("function `%#D' is initialized like a variable", decl);
7383         initialized = 0;
7384         break;
7385
7386       default:
7387         break;
7388       }
7389
7390   if (initialized)
7391     {
7392       if (! toplevel_bindings_p ()
7393           && DECL_EXTERNAL (decl))
7394         cp_warning ("declaration of `%#D' has `extern' and is initialized",
7395                     decl);
7396       DECL_EXTERNAL (decl) = 0;
7397       if (toplevel_bindings_p ())
7398         TREE_STATIC (decl) = 1;
7399
7400       /* Tell `pushdecl' this is an initialized decl
7401          even though we don't yet have the initializer expression.
7402          Also tell `cp_finish_decl' it may store the real initializer.  */
7403       DECL_INITIAL (decl) = error_mark_node;
7404     }
7405
7406 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
7407   SET_DEFAULT_DECL_ATTRIBUTES (decl, attributes);
7408 #endif
7409
7410   /* Set attributes here so if duplicate decl, will have proper attributes.  */
7411   cplus_decl_attributes (decl, attributes, prefix_attributes);
7412
7413   if (context && COMPLETE_TYPE_P (complete_type (context)))
7414     {
7415       push_nested_class (context, 2);
7416
7417       if (TREE_CODE (decl) == VAR_DECL)
7418         {
7419           tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
7420           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
7421             cp_error ("`%#D' is not a static member of `%#T'", decl, context);
7422           else
7423             {
7424               if (DECL_CONTEXT (field) != context)
7425                 {
7426                   cp_pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
7427                               DECL_CONTEXT (field), DECL_NAME (decl),
7428                               context, DECL_NAME (decl));
7429                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
7430                 }
7431               /* Static data member are tricky; an in-class initialization
7432                  still doesn't provide a definition, so the in-class
7433                  declaration will have DECL_EXTERNAL set, but will have an
7434                  initialization.  Thus, duplicate_decls won't warn
7435                  about this situation, and so we check here.  */
7436               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
7437                 cp_error ("duplicate initialization of %D", decl);
7438               if (duplicate_decls (decl, field))
7439                 decl = field;
7440             }
7441         }
7442       else
7443         {
7444           tree field = check_classfn (context, decl);
7445           if (field && duplicate_decls (decl, field))
7446             decl = field;
7447         }
7448
7449       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
7450       DECL_IN_AGGR_P (decl) = 0;
7451       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
7452           || CLASSTYPE_TEMPLATE_INSTANTIATION (context))
7453         {
7454           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
7455           /* [temp.expl.spec] An explicit specialization of a static data
7456              member of a template is a definition if the declaration
7457              includes an initializer; otherwise, it is a declaration.
7458
7459              We check for processing_specialization so this only applies
7460              to the new specialization syntax.  */
7461           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
7462             DECL_EXTERNAL (decl) = 1;
7463         }
7464
7465       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
7466         cp_pedwarn ("declaration of `%#D' outside of class is not definition",
7467                     decl);
7468     }
7469
7470   /* Enter this declaration into the symbol table.  */
7471   tem = maybe_push_decl (decl);
7472
7473   if (processing_template_decl)
7474     tem = push_template_decl (tem);
7475
7476 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7477   /* Tell the back-end to use or not use .common as appropriate.  If we say
7478      -fconserve-space, we want this to save .data space, at the expense of
7479      wrong semantics.  If we say -fno-conserve-space, we want this to
7480      produce errors about redefs; to do this we force variables into the
7481      data segment.  */
7482   DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
7483 #endif
7484
7485   if (! processing_template_decl)
7486     start_decl_1 (tem);
7487
7488   return tem;
7489 }
7490
7491 void
7492 start_decl_1 (decl)
7493      tree decl;
7494 {
7495   tree type = TREE_TYPE (decl);
7496   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
7497
7498   if (type == error_mark_node)
7499     return;
7500
7501   /* If this type of object needs a cleanup, but we're not allowed to
7502      add any more objects with cleanups to the current scope, create a
7503      new binding level.  */
7504   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
7505       && current_binding_level->more_cleanups_ok == 0)
7506     {
7507       keep_next_level (2);
7508       pushlevel (1);
7509       clear_last_expr ();
7510       add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
7511     }
7512
7513   if (initialized)
7514     /* Is it valid for this decl to have an initializer at all?
7515        If not, set INITIALIZED to zero, which will indirectly
7516        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7517     {
7518       /* Don't allow initializations for incomplete types except for
7519          arrays which might be completed by the initialization.  */
7520       if (COMPLETE_TYPE_P (complete_type (type)))
7521         ;                       /* A complete type is ok.  */
7522       else if (TREE_CODE (type) != ARRAY_TYPE)
7523         {
7524           cp_error ("variable `%#D' has initializer but incomplete type",
7525                     decl);
7526           initialized = 0;
7527           type = TREE_TYPE (decl) = error_mark_node;
7528         }
7529       else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7530         {
7531           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
7532             cp_error ("elements of array `%#D' have incomplete type", decl);
7533           /* else we already gave an error in start_decl.  */
7534           initialized = 0;
7535         }
7536     }
7537
7538   if (!initialized
7539       && TREE_CODE (decl) != TYPE_DECL
7540       && TREE_CODE (decl) != TEMPLATE_DECL
7541       && type != error_mark_node
7542       && IS_AGGR_TYPE (type)
7543       && ! DECL_EXTERNAL (decl))
7544     {
7545       if ((! processing_template_decl || ! uses_template_parms (type))
7546           && !COMPLETE_TYPE_P (complete_type (type)))
7547         {
7548           cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
7549                  decl);
7550           /* Change the type so that assemble_variable will give
7551              DECL an rtl we can live with: (mem (const_int 0)).  */
7552           type = TREE_TYPE (decl) = error_mark_node;
7553         }
7554       else
7555         {
7556           /* If any base type in the hierarchy of TYPE needs a constructor,
7557              then we set initialized to 1.  This way any nodes which are
7558              created for the purposes of initializing this aggregate
7559              will live as long as it does.  This is necessary for global
7560              aggregates which do not have their initializers processed until
7561              the end of the file.  */
7562           initialized = TYPE_NEEDS_CONSTRUCTING (type);
7563         }
7564     }
7565
7566   if (! initialized)
7567     DECL_INITIAL (decl) = NULL_TREE;
7568 }
7569
7570 /* Handle initialization of references.
7571    These three arguments are from `cp_finish_decl', and have the
7572    same meaning here that they do there.
7573
7574    Quotes on semantics can be found in ARM 8.4.3.  */
7575
7576 static void
7577 grok_reference_init (decl, type, init)
7578      tree decl, type, init;
7579 {
7580   tree tmp;
7581
7582   if (init == NULL_TREE)
7583     {
7584       if ((DECL_LANG_SPECIFIC (decl) == 0
7585            || DECL_IN_AGGR_P (decl) == 0)
7586           && ! DECL_THIS_EXTERN (decl))
7587         cp_error ("`%D' declared as reference but not initialized", decl);
7588       return;
7589     }
7590
7591   if (init == error_mark_node)
7592     return;
7593
7594   if (TREE_CODE (init) == CONSTRUCTOR)
7595     {
7596       cp_error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
7597       return;
7598     }
7599
7600   if (TREE_CODE (init) == TREE_LIST)
7601     init = build_compound_expr (init);
7602
7603   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
7604     init = convert_from_reference (init);
7605
7606   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
7607       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
7608     {
7609       /* Note: default conversion is only called in very special cases.  */
7610       init = default_conversion (init);
7611     }
7612
7613   /* Convert INIT to the reference type TYPE.  This may involve the
7614      creation of a temporary, whose lifetime must be the same as that
7615      of the reference.  If so, a DECL_STMT for the temporary will be
7616      added just after the DECL_STMT for DECL.  That's why we don't set
7617      DECL_INITIAL for local references (instead assigning to them
7618      explicitly); we need to allow the temporary to be initialized
7619      first.  */
7620   tmp = convert_to_reference
7621     (type, init, CONV_IMPLICIT,
7622      LOOKUP_ONLYCONVERTING|LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND,
7623      decl);
7624
7625   if (tmp == error_mark_node)
7626     return;
7627   else if (tmp != NULL_TREE)
7628     {
7629       init = tmp;
7630       tmp = save_expr (tmp);
7631       if (building_stmt_tree ())
7632         {
7633           /* Initialize the declaration.  */
7634           tmp = build (INIT_EXPR, TREE_TYPE (decl), decl, tmp);
7635           finish_expr_stmt (tmp);
7636         }
7637       else
7638         DECL_INITIAL (decl) = tmp;
7639     }
7640   else
7641     {
7642       cp_error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
7643       return;
7644     }
7645
7646   if (TREE_STATIC (decl) && ! TREE_CONSTANT (DECL_INITIAL (decl)))
7647     {
7648       expand_static_init (decl, DECL_INITIAL (decl));
7649       DECL_INITIAL (decl) = NULL_TREE;
7650     }
7651   return;
7652 }
7653
7654 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7655    mucking with forces it does not comprehend (i.e. initialization with a
7656    constructor).  If we are at global scope and won't go into COMMON, fill
7657    it in with a dummy CONSTRUCTOR to force the variable into .data;
7658    otherwise we can use error_mark_node.  */
7659
7660 static tree
7661 obscure_complex_init (decl, init)
7662      tree decl, init;
7663 {
7664   if (! flag_no_inline && TREE_STATIC (decl))
7665     {
7666       if (extract_init (decl, init))
7667         return NULL_TREE;
7668     }
7669
7670 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7671   if (toplevel_bindings_p () && ! DECL_COMMON (decl))
7672     DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
7673                                  NULL_TREE);
7674   else
7675 #endif
7676     DECL_INITIAL (decl) = error_mark_node;
7677
7678   return init;
7679 }
7680
7681 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7682    array until we finish parsing the initializer.  If that's the
7683    situation we're in, update DECL accordingly.  */
7684
7685 static void
7686 maybe_deduce_size_from_array_init (decl, init)
7687      tree decl;
7688      tree init;
7689 {
7690   tree type = TREE_TYPE (decl);
7691
7692   if (TREE_CODE (type) == ARRAY_TYPE
7693       && TYPE_DOMAIN (type) == NULL_TREE
7694       && TREE_CODE (decl) != TYPE_DECL)
7695     {
7696       int do_default
7697         = (TREE_STATIC (decl)
7698            /* Even if pedantic, an external linkage array
7699               may have incomplete type at first.  */
7700            ? pedantic && ! DECL_EXTERNAL (decl)
7701            : !DECL_EXTERNAL (decl));
7702       tree initializer = init ? init : DECL_INITIAL (decl);
7703       int failure = complete_array_type (type, initializer, do_default);
7704
7705       if (failure == 1)
7706         cp_error ("initializer fails to determine size of `%D'", decl);
7707
7708       if (failure == 2)
7709         {
7710           if (do_default)
7711             cp_error ("array size missing in `%D'", decl);
7712           /* If a `static' var's size isn't known, make it extern as
7713              well as static, so it does not get allocated.  If it's not
7714              `static', then don't mark it extern; finish_incomplete_decl
7715              will give it a default size and it will get allocated.  */
7716           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7717             DECL_EXTERNAL (decl) = 1;
7718         }
7719
7720       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7721           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7722                               integer_zero_node))
7723         cp_error ("zero-size array `%D'", decl);
7724
7725       layout_decl (decl, 0);
7726     }
7727 }
7728
7729 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7730    any appropriate error messages regarding the layout.  */
7731
7732 static void
7733 layout_var_decl (decl)
7734      tree decl;
7735 {
7736   tree type = TREE_TYPE (decl);
7737 #if 0
7738   tree ttype = target_type (type);
7739 #endif
7740
7741   /* If we haven't already layed out this declaration, do so now.
7742      Note that we must not call complete type for an external object
7743      because it's type might involve templates that we are not
7744      supposed to isntantiate yet.  (And it's perfectly legal to say
7745      `extern X x' for some incomplete type `X'.)  */
7746   if (!DECL_EXTERNAL (decl))
7747     complete_type (type);
7748   if (!DECL_SIZE (decl) && COMPLETE_TYPE_P (type))
7749     layout_decl (decl, 0);
7750
7751   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7752     {
7753       /* An automatic variable with an incomplete type: that is an error.
7754          Don't talk about array types here, since we took care of that
7755          message in grokdeclarator.  */
7756       cp_error ("storage size of `%D' isn't known", decl);
7757       TREE_TYPE (decl) = error_mark_node;
7758     }
7759 #if 0
7760   /* Keep this code around in case we later want to control debug info
7761      based on whether a type is "used".  (jason 1999-11-11) */
7762
7763   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7764     /* Let debugger know it should output info for this type.  */
7765     note_debug_info_needed (ttype);
7766
7767   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7768     note_debug_info_needed (DECL_CONTEXT (decl));
7769 #endif
7770
7771   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7772       && DECL_SIZE (decl) != NULL_TREE
7773       && ! TREE_CONSTANT (DECL_SIZE (decl)))
7774     {
7775       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7776         constant_expression_warning (DECL_SIZE (decl));
7777       else
7778         cp_error ("storage size of `%D' isn't constant", decl);
7779     }
7780 }
7781
7782 /* If a local static variable is declared in an inline function, or if
7783    we have a weak definition, we must endeavor to create only one
7784    instance of the variable at link-time.  */
7785
7786 static void
7787 maybe_commonize_var (decl)
7788      tree decl;
7789 {
7790   /* Static data in a function with comdat linkage also has comdat
7791      linkage.  */
7792   if (TREE_STATIC (decl)
7793       /* Don't mess with __FUNCTION__.  */
7794       && ! DECL_ARTIFICIAL (decl)
7795       && current_function_decl
7796       && DECL_CONTEXT (decl) == current_function_decl
7797       && (DECL_THIS_INLINE (current_function_decl)
7798           || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7799       && TREE_PUBLIC (current_function_decl))
7800     {
7801       /* Rather than try to get this right with inlining, we suppress
7802          inlining of such functions.  */
7803       current_function_cannot_inline
7804         = "function with static variable cannot be inline";
7805
7806       /* If flag_weak, we don't need to mess with this, as we can just
7807          make the function weak, and let it refer to its unique local
7808          copy.  This works because we don't allow the function to be
7809          inlined.  */
7810       if (! flag_weak)
7811         {
7812           if (DECL_INTERFACE_KNOWN (current_function_decl))
7813             {
7814               TREE_PUBLIC (decl) = 1;
7815               DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7816             }
7817           else if (DECL_INITIAL (decl) == NULL_TREE
7818                    || DECL_INITIAL (decl) == error_mark_node)
7819             {
7820               TREE_PUBLIC (decl) = 1;
7821               DECL_COMMON (decl) = 1;
7822             }
7823           /* else we lose. We can only do this if we can use common,
7824              which we can't if it has been initialized.  */
7825
7826           if (TREE_PUBLIC (decl))
7827             DECL_ASSEMBLER_NAME (decl)
7828               = build_static_name (current_function_decl, DECL_NAME (decl));
7829           else
7830             {
7831               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7832               cp_warning_at ("  you can work around this by removing the initializer", decl);
7833             }
7834         }
7835     }
7836   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7837     /* Set it up again; we might have set DECL_INITIAL since the last
7838        time.  */
7839     comdat_linkage (decl);
7840 }
7841
7842 /* Issue an error message if DECL is an uninitialized const variable.  */
7843
7844 static void
7845 check_for_uninitialized_const_var (decl)
7846      tree decl;
7847 {
7848   tree type = TREE_TYPE (decl);
7849
7850   /* ``Unless explicitly declared extern, a const object does not have
7851      external linkage and must be initialized. ($8.4; $12.1)'' ARM
7852      7.1.6 */
7853   if (TREE_CODE (decl) == VAR_DECL
7854       && TREE_CODE (type) != REFERENCE_TYPE
7855       && CP_TYPE_CONST_P (type)
7856       && !TYPE_NEEDS_CONSTRUCTING (type)
7857       && !DECL_INITIAL (decl))
7858     cp_error ("uninitialized const `%D'", decl);
7859 }
7860
7861 /* Verify INIT (the initializer for DECL), and record the
7862    initialization in DECL_INITIAL, if appropriate.  Returns a new
7863    value for INIT.  */
7864
7865 static tree
7866 check_initializer (decl, init)
7867      tree decl;
7868      tree init;
7869 {
7870   tree type;
7871
7872   if (TREE_CODE (decl) == FIELD_DECL)
7873     return init;
7874
7875   type = TREE_TYPE (decl);
7876
7877   /* If `start_decl' didn't like having an initialization, ignore it now.  */
7878   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7879     init = NULL_TREE;
7880
7881   /* Check the initializer.  */
7882   if (init)
7883     {
7884       /* Things that are going to be initialized need to have complete
7885          type.  */
7886       TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7887
7888       if (type == error_mark_node)
7889         /* We will have already complained.  */
7890         init = NULL_TREE;
7891       else if (COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
7892         {
7893           cp_error ("variable-sized object `%D' may not be initialized", decl);
7894           init = NULL_TREE;
7895         }
7896       else if (TREE_CODE (type) == ARRAY_TYPE
7897                && !COMPLETE_TYPE_P (TREE_TYPE (type)))
7898         {
7899           cp_error ("elements of array `%#D' have incomplete type", decl);
7900           init = NULL_TREE;
7901         }
7902       else if (!COMPLETE_TYPE_P (type))
7903         {
7904           cp_error ("`%D' has incomplete type", decl);
7905           TREE_TYPE (decl) = error_mark_node;
7906           init = NULL_TREE;
7907         }
7908     }
7909
7910   if (TREE_CODE (decl) == CONST_DECL)
7911     {
7912       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7913
7914       DECL_INITIAL (decl) = init;
7915
7916       /* This will keep us from needing to worry about our obstacks.  */
7917       my_friendly_assert (init != NULL_TREE, 149);
7918       init = NULL_TREE;
7919     }
7920   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7921     {
7922       if (TREE_STATIC (decl))
7923         make_decl_rtl (decl, NULL_PTR, toplevel_bindings_p ());
7924       grok_reference_init (decl, type, init);
7925       init = NULL_TREE;
7926     }
7927   else if (init)
7928     {
7929       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7930         {
7931           if (TREE_CODE (type) == ARRAY_TYPE)
7932             init = digest_init (type, init, (tree *) 0);
7933           else if (TREE_CODE (init) == CONSTRUCTOR
7934                    && TREE_HAS_CONSTRUCTOR (init))
7935             {
7936               if (TYPE_NON_AGGREGATE_CLASS (type))
7937                 {
7938                   cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7939                             decl);
7940                   init = error_mark_node;
7941                 }
7942               else
7943                 goto dont_use_constructor;
7944             }
7945         }
7946       else
7947         {
7948         dont_use_constructor:
7949           if (TREE_CODE (init) != TREE_VEC)
7950             init = store_init_value (decl, init);
7951         }
7952
7953       if (init)
7954         /* We must hide the initializer so that expand_decl
7955            won't try to do something it does not understand.  */
7956         init = obscure_complex_init (decl, init);
7957     }
7958   else if (DECL_EXTERNAL (decl))
7959     ;
7960   else if (TYPE_P (type)
7961            && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
7962     {
7963       tree core_type = strip_array_types (type);
7964
7965       if (! TYPE_NEEDS_CONSTRUCTING (core_type))
7966         {
7967           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
7968             cp_error ("structure `%D' with uninitialized const members", decl);
7969           if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
7970             cp_error ("structure `%D' with uninitialized reference members",
7971                       decl);
7972         }
7973
7974       check_for_uninitialized_const_var (decl);
7975
7976       if (COMPLETE_TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
7977         init = obscure_complex_init (decl, NULL_TREE);
7978
7979     }
7980   else
7981     check_for_uninitialized_const_var (decl);
7982
7983   return init;
7984 }
7985
7986 /* If DECL is not a local variable, give it RTL.  */
7987
7988 static void
7989 make_rtl_for_nonlocal_decl (decl, init, asmspec)
7990      tree decl;
7991      tree init;
7992      const char *asmspec;
7993 {
7994   int toplev = toplevel_bindings_p ();
7995   int defer_p;
7996
7997   /* Handle non-variables up front.  */
7998   if (TREE_CODE (decl) != VAR_DECL)
7999     {
8000       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
8001       return;
8002     }
8003
8004   /* If we see a class member here, it should be a static data
8005      member.  */
8006   if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
8007     {
8008       my_friendly_assert (TREE_STATIC (decl), 19990828);
8009       /* An in-class declaration of a static data member should be
8010          external; it is only a declaration, and not a definition.  */
8011       if (init == NULL_TREE)
8012         my_friendly_assert (DECL_EXTERNAL (decl), 20000723);
8013     }
8014
8015   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
8016   if (asmspec)
8017     DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
8018
8019   /* We don't create any RTL for local variables.  */
8020   if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
8021     return;
8022
8023   /* We defer emission of local statics until the corresponding
8024      DECL_STMT is expanded.  */
8025   defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
8026
8027   /* We try to defer namespace-scope static constants so that they are
8028      not emitted into the object file unncessarily.  */
8029   if (!DECL_VIRTUAL_P (decl)
8030       && TREE_READONLY (decl)
8031       && DECL_INITIAL (decl) != NULL_TREE
8032       && DECL_INITIAL (decl) != error_mark_node
8033       && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
8034       && toplev
8035       && !TREE_PUBLIC (decl))
8036     {
8037       /* Fool with the linkage according to #pragma interface.  */
8038       if (!interface_unknown)
8039         {
8040           TREE_PUBLIC (decl) = 1;
8041           DECL_EXTERNAL (decl) = interface_only;
8042         }
8043
8044       defer_p = 1;
8045     }
8046
8047   /* If we're deferring the variable, just make RTL.  Do not actually
8048      emit the variable.  */
8049   if (defer_p)
8050     make_decl_rtl (decl, asmspec, toplev);
8051   /* If we're not deferring, go ahead and assemble the variable.  */
8052   else
8053     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
8054 }
8055
8056 /* The old ARM scoping rules injected variables declared in the
8057    initialization statement of a for-statement into the surrounding
8058    scope.  We support this usage, in order to be backward-compatible.
8059    DECL is a just-declared VAR_DECL; if necessary inject its
8060    declaration into the surrounding scope.  */
8061
8062 void
8063 maybe_inject_for_scope_var (decl)
8064      tree decl;
8065 {
8066   if (!DECL_NAME (decl))
8067     return;
8068
8069   if (current_binding_level->is_for_scope)
8070     {
8071       struct binding_level *outer
8072         = current_binding_level->level_chain;
8073
8074       /* Check to see if the same name is already bound at the outer
8075          level, either because it was directly declared, or because a
8076          dead for-decl got preserved.  In either case, the code would
8077          not have been valid under the ARM scope rules, so clear
8078          is_for_scope for the current_binding_level.
8079
8080          Otherwise, we need to preserve the temp slot for decl to last
8081          into the outer binding level.  */
8082
8083       tree outer_binding
8084         = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
8085
8086       if (outer_binding && BINDING_LEVEL (outer_binding) == outer
8087           && (TREE_CODE (BINDING_VALUE (outer_binding))
8088               == VAR_DECL)
8089           && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
8090         {
8091           BINDING_VALUE (outer_binding)
8092             = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
8093           current_binding_level->is_for_scope = 0;
8094         }
8095       else if (DECL_IN_MEMORY_P (decl))
8096         preserve_temp_slots (DECL_RTL (decl));
8097     }
8098 }
8099
8100 /* Generate code to initialize DECL (a local variable).  */
8101
8102 void
8103 initialize_local_var (decl, init, flags)
8104      tree decl;
8105      tree init;
8106      int flags;
8107 {
8108   tree type = TREE_TYPE (decl);
8109
8110   /* If the type is bogus, don't bother initializing the variable.  */
8111   if (type == error_mark_node)
8112     return;
8113
8114   if (DECL_SIZE (decl) == NULL_TREE && !TREE_STATIC (decl))
8115     {
8116       /* If we used it already as memory, it must stay in memory.  */
8117       DECL_INITIAL (decl) = NULL_TREE;
8118       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
8119     }
8120
8121   /* Local statics are handled differently from ordinary automatic
8122      variables.  */
8123   if (TREE_STATIC (decl))
8124     {
8125       if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
8126           || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8127         expand_static_init (decl, init);
8128       return;
8129     }
8130
8131   if (DECL_SIZE (decl) && type != error_mark_node)
8132     {
8133       int already_used;
8134
8135       /* Compute and store the initial value.  */
8136       already_used = TREE_USED (decl) || TREE_USED (type);
8137
8138       if (init || TYPE_NEEDS_CONSTRUCTING (type))
8139         {
8140           int saved_stmts_are_full_exprs_p;
8141
8142           my_friendly_assert (building_stmt_tree (), 20000906);
8143           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
8144           current_stmt_tree ()->stmts_are_full_exprs_p = 1;
8145           finish_expr_stmt (build_aggr_init (decl, init, flags));
8146           current_stmt_tree ()->stmts_are_full_exprs_p =
8147             saved_stmts_are_full_exprs_p;
8148         }
8149
8150       /* Set this to 0 so we can tell whether an aggregate which was
8151          initialized was ever used.  Don't do this if it has a
8152          destructor, so we don't complain about the 'resource
8153          allocation is initialization' idiom.  Now set
8154          attribute((unused)) on types so decls of that type will be
8155          marked used. (see TREE_USED, above.)  */
8156       if (TYPE_NEEDS_CONSTRUCTING (type)
8157           && ! already_used
8158           && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
8159           && DECL_NAME (decl))
8160         TREE_USED (decl) = 0;
8161       else if (already_used)
8162         TREE_USED (decl) = 1;
8163     }
8164 }
8165
8166 /* Generate code to destroy DECL (a local variable).  */
8167
8168 static void
8169 destroy_local_var (decl)
8170      tree decl;
8171 {
8172   tree type = TREE_TYPE (decl);
8173   tree cleanup;
8174
8175   /* Only variables get cleaned up.  */
8176   if (TREE_CODE (decl) != VAR_DECL)
8177     return;
8178
8179   /* And only things with destructors need cleaning up.  */
8180   if (type == error_mark_node
8181       || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
8182     return;
8183
8184   if (TREE_CODE (decl) == VAR_DECL &&
8185       (DECL_EXTERNAL (decl) || TREE_STATIC (decl)))
8186     /* We don't clean up things that aren't defined in this
8187        translation unit, or that need a static cleanup.  The latter
8188        are handled by finish_file.  */
8189     return;
8190
8191   /* Compute the cleanup.  */
8192   cleanup = maybe_build_cleanup (decl);
8193
8194   /* Record the cleanup required for this declaration.  */
8195   if (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node
8196       && cleanup)
8197     finish_decl_cleanup (decl, cleanup);
8198 }
8199
8200 /* Finish processing of a declaration;
8201    install its line number and initial value.
8202    If the length of an array type is not known before,
8203    it must be determined now, from the initial value, or it is an error.
8204
8205    INIT holds the value of an initializer that should be allowed to escape
8206    the normal rules.
8207
8208    FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
8209    if the (init) syntax was used.  */
8210
8211 void
8212 cp_finish_decl (decl, init, asmspec_tree, flags)
8213      tree decl, init;
8214      tree asmspec_tree;
8215      int flags;
8216 {
8217   register tree type;
8218   tree ttype = NULL_TREE;
8219   const char *asmspec = NULL;
8220   int was_readonly = 0;
8221
8222   if (! decl)
8223     {
8224       if (init)
8225         error ("assignment (not initialization) in declaration");
8226       return;
8227     }
8228
8229   /* If a name was specified, get the string.  */
8230   if (asmspec_tree)
8231       asmspec = TREE_STRING_POINTER (asmspec_tree);
8232
8233   if (init && TREE_CODE (init) == NAMESPACE_DECL)
8234     {
8235       cp_error ("cannot initialize `%D' to namespace `%D'",
8236                 decl, init);
8237       init = NULL_TREE;
8238     }
8239
8240   if (current_class_type
8241       && CP_DECL_CONTEXT (decl) == current_class_type
8242       && TYPE_BEING_DEFINED (current_class_type)
8243       && (DECL_INITIAL (decl) || init))
8244     DECL_DEFINED_IN_CLASS_P (decl) = 1;
8245
8246   if (TREE_CODE (decl) == VAR_DECL
8247       && DECL_CONTEXT (decl)
8248       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
8249       && DECL_CONTEXT (decl) != current_namespace
8250       && init)
8251     {
8252       /* Leave the namespace of the object. */
8253       pop_decl_namespace ();
8254     }
8255
8256   type = TREE_TYPE (decl);
8257
8258   if (type == error_mark_node)
8259     return;
8260
8261   /* Add this declaration to the statement-tree.  */
8262   if (building_stmt_tree ()
8263       && at_function_scope_p ()
8264       && TREE_CODE (decl) != RESULT_DECL)
8265     add_decl_stmt (decl);
8266
8267   if (TYPE_HAS_MUTABLE_P (type))
8268     TREE_READONLY (decl) = 0;
8269
8270   if (processing_template_decl)
8271     {
8272       if (init && DECL_INITIAL (decl))
8273         DECL_INITIAL (decl) = init;
8274       goto finish_end0;
8275     }
8276
8277   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
8278   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
8279
8280   /* Take care of TYPE_DECLs up front.  */
8281   if (TREE_CODE (decl) == TYPE_DECL)
8282     {
8283       if (init && DECL_INITIAL (decl))
8284         {
8285           /* typedef foo = bar; store the type of bar as the type of foo.  */
8286           TREE_TYPE (decl) = type = TREE_TYPE (init);
8287           DECL_INITIAL (decl) = init = NULL_TREE;
8288         }
8289       if (type != error_mark_node
8290           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
8291         {
8292           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
8293             cp_warning ("shadowing previous type declaration of `%#D'", decl);
8294           set_identifier_type_value (DECL_NAME (decl), type);
8295           CLASSTYPE_GOT_SEMICOLON (type) = 1;
8296         }
8297       GNU_xref_decl (current_function_decl, decl);
8298
8299       /* If we have installed this as the canonical typedef for this
8300          type, and that type has not been defined yet, delay emitting
8301          the debug information for it, as we will emit it later.  */
8302       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
8303           && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
8304         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
8305
8306       rest_of_decl_compilation (decl, NULL_PTR,
8307                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
8308       goto finish_end;
8309     }
8310
8311   if (TREE_CODE (decl) != FUNCTION_DECL)
8312     ttype = target_type (type);
8313
8314   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
8315       && TYPE_NEEDS_CONSTRUCTING (type))
8316     {
8317       /* Currently, GNU C++ puts constants in text space, making them
8318          impossible to initialize.  In the future, one would hope for
8319          an operating system which understood the difference between
8320          initialization and the running of a program.  */
8321       was_readonly = 1;
8322       TREE_READONLY (decl) = 0;
8323     }
8324
8325   if (TREE_CODE (decl) == FIELD_DECL && asmspec)
8326     {
8327       /* This must override the asm specifier which was placed by
8328          grokclassfn.  Lay this out fresh.  */
8329       DECL_RTL (TREE_TYPE (decl)) = NULL_RTX;
8330       DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
8331       make_decl_rtl (decl, asmspec, 0);
8332     }
8333
8334   /* Deduce size of array from initialization, if not already known.  */
8335   maybe_deduce_size_from_array_init (decl, init);
8336   init = check_initializer (decl, init);
8337
8338   GNU_xref_decl (current_function_decl, decl);
8339
8340   if (TREE_CODE (decl) == VAR_DECL)
8341     layout_var_decl (decl);
8342
8343   /* Output the assembler code and/or RTL code for variables and functions,
8344      unless the type is an undefined structure or union.
8345      If not, it will get done when the type is completed.  */
8346   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
8347       || TREE_CODE (decl) == RESULT_DECL)
8348     {
8349       if (TREE_CODE (decl) == VAR_DECL)
8350         maybe_commonize_var (decl);
8351
8352       make_rtl_for_nonlocal_decl (decl, init, asmspec);
8353
8354       if (TREE_CODE (type) == FUNCTION_TYPE
8355           || TREE_CODE (type) == METHOD_TYPE)
8356         abstract_virtuals_error (decl,
8357                                  strip_array_types (TREE_TYPE (type)));
8358       else
8359         abstract_virtuals_error (decl, strip_array_types (type));
8360
8361       if (TREE_CODE (decl) == FUNCTION_DECL)
8362         ;
8363       else if (DECL_EXTERNAL (decl)
8364                && ! (DECL_LANG_SPECIFIC (decl)
8365                      && DECL_NOT_REALLY_EXTERN (decl)))
8366         {
8367           if (init)
8368             DECL_INITIAL (decl) = init;
8369         }
8370       else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
8371         {
8372           /* This is a local declaration.  */
8373           if (doing_semantic_analysis_p ())
8374             maybe_inject_for_scope_var (decl);
8375           /* Initialize the local variable.  But, if we're building a
8376              statement-tree, we'll do the initialization when we
8377              expand the tree.  */
8378           if (processing_template_decl)
8379             {
8380               if (init || DECL_INITIAL (decl) == error_mark_node)
8381                 DECL_INITIAL (decl) = init;
8382             }
8383           else
8384             {
8385               /* If we're not building RTL, then we need to do so
8386                  now.  */
8387               my_friendly_assert (building_stmt_tree (), 20000906);
8388               /* Initialize the variable.  */
8389               initialize_local_var (decl, init, flags);
8390               /* Clean up the variable.  */
8391               destroy_local_var (decl);
8392             }
8393         }
8394       else if (TREE_STATIC (decl) && type != error_mark_node)
8395         {
8396           /* Cleanups for static variables are handled by `finish_file'.  */
8397           if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
8398               || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8399             expand_static_init (decl, init);
8400         }
8401     finish_end0:
8402
8403       /* Undo call to `pushclass' that was done in `start_decl'
8404          due to initialization of qualified member variable.
8405          I.e., Foo::x = 10;  */
8406       {
8407         tree context = CP_DECL_CONTEXT (decl);
8408         if (context
8409             && TYPE_P (context)
8410             && (TREE_CODE (decl) == VAR_DECL
8411                 /* We also have a pushclass done that we need to undo here
8412                    if we're at top level and declare a method.  */
8413                 || TREE_CODE (decl) == FUNCTION_DECL)
8414             /* If size hasn't been set, we're still defining it,
8415                and therefore inside the class body; don't pop
8416                the binding level..  */
8417             && COMPLETE_TYPE_P (context)
8418             && context == current_class_type)
8419           pop_nested_class ();
8420       }
8421     }
8422
8423  finish_end:
8424
8425   if (was_readonly)
8426     TREE_READONLY (decl) = 1;
8427 }
8428
8429 /* This is here for a midend callback from c-common.c */
8430
8431 void
8432 finish_decl (decl, init, asmspec_tree)
8433      tree decl, init;
8434      tree asmspec_tree;
8435 {
8436   cp_finish_decl (decl, init, asmspec_tree, 0);
8437 }
8438
8439 /* Returns a declaration for a VAR_DECL as if:
8440
8441      extern "C" TYPE NAME;
8442
8443    had been seen.  Used to create compiler-generated global
8444    variables.  */
8445
8446 tree
8447 declare_global_var (name, type)
8448      tree name;
8449      tree type;
8450 {
8451   tree decl;
8452
8453   push_to_top_level ();
8454   decl = build_decl (VAR_DECL, name, type);
8455   TREE_PUBLIC (decl) = 1;
8456   DECL_EXTERNAL (decl) = 1;
8457   DECL_ARTIFICIAL (decl) = 1;
8458   pushdecl (decl);
8459   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
8460   pop_from_top_level ();
8461
8462   return decl;
8463 }
8464
8465 /* Returns a pointer to the `atexit' function.  Note that if
8466    FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
8467    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
8468
8469 static tree
8470 get_atexit_node ()
8471 {
8472   tree atexit_fndecl;
8473   tree arg_types;
8474   tree fn_type;
8475   tree fn_ptr_type;
8476   const char *name;
8477
8478   if (atexit_node)
8479     return atexit_node;
8480
8481   if (flag_use_cxa_atexit)
8482     {
8483       /* The declaration for `__cxa_atexit' is:
8484
8485            int __cxa_atexit (void (*)(void *), void *, void *)
8486
8487          We build up the argument types and then then function type
8488          itself.  */
8489
8490       /* First, build the pointer-to-function type for the first
8491          argument.  */
8492       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8493       fn_type = build_function_type (void_type_node, arg_types);
8494       fn_ptr_type = build_pointer_type (fn_type);
8495       /* Then, build the rest of the argument types.  */
8496       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8497       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
8498       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
8499       /* And the final __cxa_atexit type.  */
8500       fn_type = build_function_type (integer_type_node, arg_types);
8501       fn_ptr_type = build_pointer_type (fn_type);
8502       name = "__cxa_atexit";
8503     }
8504   else
8505     {
8506       /* The declaration for `atexit' is:
8507
8508            int atexit (void (*)());
8509
8510          We build up the argument types and then then function type
8511          itself.  */
8512       fn_type = build_function_type (void_type_node, void_list_node);
8513       fn_ptr_type = build_pointer_type (fn_type);
8514       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
8515       /* Build the final atexit type.  */
8516       fn_type = build_function_type (integer_type_node, arg_types);
8517       name = "atexit";
8518     }
8519
8520   /* Now, build the function declaration.  */
8521   push_lang_context (lang_name_c);
8522   atexit_fndecl = build_library_fn_ptr (name, fn_type);
8523   mark_used (atexit_fndecl);
8524   pop_lang_context ();
8525   atexit_node = default_conversion (atexit_fndecl);
8526
8527   return atexit_node;
8528 }
8529
8530 /* Returns the __dso_handle VAR_DECL.  */
8531
8532 static tree
8533 get_dso_handle_node ()
8534 {
8535   if (dso_handle_node)
8536     return dso_handle_node;
8537
8538   /* Declare the variable.  */
8539   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8540                                         ptr_type_node);
8541
8542   return dso_handle_node;
8543 }
8544
8545 /* Begin a new function with internal linkage whose job will be simply
8546    to destroy some particular variable.  */
8547
8548 static tree
8549 start_cleanup_fn ()
8550 {
8551   static int counter = 0;
8552   int old_interface_unknown = interface_unknown;
8553   char name[32];
8554   tree parmtypes;
8555   tree fntype;
8556   tree fndecl;
8557
8558   push_to_top_level ();
8559
8560   /* No need to mangle this.  */
8561   push_lang_context (lang_name_c);
8562
8563   interface_unknown = 1;
8564
8565   /* Build the parameter-types.  */
8566   parmtypes = void_list_node;
8567   /* Functions passed to __cxa_atexit take an additional parameter.
8568      We'll just ignore it.  After we implement the new calling
8569      convention for destructors, we can eliminate the use of
8570      additional cleanup functions entirely in the -fnew-abi case.  */
8571   if (flag_use_cxa_atexit)
8572     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8573   /* Build the function type itself.  */
8574   fntype = build_function_type (void_type_node, parmtypes);
8575   /* Build the name of the function.  */
8576   sprintf (name, "__tcf_%d", counter++);
8577   /* Build the function declaration.  */
8578   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8579   /* It's a function with internal linkage, generated by the
8580      compiler.  */
8581   TREE_PUBLIC (fndecl) = 0;
8582   DECL_ARTIFICIAL (fndecl) = 1;
8583   /* Make the function `inline' so that it is only emitted if it is
8584      actually needed.  It is unlikely that it will be inlined, since
8585      it is only called via a function pointer, but we avoid unncessary
8586      emissions this way.  */
8587   DECL_INLINE (fndecl) = 1;
8588   /* Build the parameter.  */
8589   if (flag_use_cxa_atexit)
8590     {
8591       tree parmdecl;
8592
8593       parmdecl = build_decl (PARM_DECL, NULL_TREE, ptr_type_node);
8594       DECL_CONTEXT (parmdecl) = fndecl;
8595       DECL_ARG_TYPE (parmdecl) = ptr_type_node;
8596       TREE_USED (parmdecl) = 1;
8597       DECL_ARGUMENTS (fndecl) = parmdecl;
8598     }
8599
8600   pushdecl (fndecl);
8601   start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8602   do_pushlevel ();
8603
8604   interface_unknown = old_interface_unknown;
8605
8606   pop_lang_context ();
8607
8608   return current_function_decl;
8609 }
8610
8611 /* Finish the cleanup function begun by start_cleanup_fn.  */
8612
8613 static void
8614 end_cleanup_fn ()
8615 {
8616   do_poplevel ();
8617
8618   expand_body (finish_function (0));
8619
8620   pop_from_top_level ();
8621 }
8622
8623 /* Generate code to handle the destruction of DECL, an object with
8624    static storage duration.  */
8625
8626 void
8627 register_dtor_fn (decl)
8628      tree decl;
8629 {
8630   tree cleanup;
8631   tree compound_stmt;
8632   tree args;
8633   tree fcall;
8634
8635   int saved_flag_access_control;
8636
8637   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8638     return;
8639
8640   /* Call build_cleanup before we enter the anonymous function so that
8641      any access checks will be done relative to the current scope,
8642      rather than the scope of the anonymous function.  */
8643   build_cleanup (decl);
8644
8645   /* Now start the function.  */
8646   cleanup = start_cleanup_fn ();
8647
8648   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
8649      to the original function, rather than the anonymous one.  That
8650      will make the back-end think that nested functions are in use,
8651      which causes confusion.  */
8652   saved_flag_access_control = flag_access_control;
8653   flag_access_control = 0;
8654   fcall = build_cleanup (decl);
8655   flag_access_control = saved_flag_access_control;
8656
8657   /* Create the body of the anonymous function.  */
8658   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8659   finish_expr_stmt (fcall);
8660   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8661   end_cleanup_fn ();
8662
8663   /* Call atexit with the cleanup function.  */
8664   mark_addressable (cleanup);
8665   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8666   if (flag_use_cxa_atexit)
8667     {
8668       args = tree_cons (NULL_TREE, get_dso_handle_node (), NULL_TREE);
8669       args = tree_cons (NULL_TREE, null_pointer_node, args);
8670       args = tree_cons (NULL_TREE, cleanup, args);
8671     }
8672   else
8673     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8674   finish_expr_stmt (build_function_call (get_atexit_node (), args));
8675 }
8676
8677 void
8678 expand_static_init (decl, init)
8679      tree decl;
8680      tree init;
8681 {
8682   tree oldstatic = value_member (decl, static_aggregates);
8683
8684   if (oldstatic)
8685     {
8686       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8687         cp_error ("multiple initializations given for `%D'", decl);
8688     }
8689   else if (! toplevel_bindings_p ())
8690     {
8691       /* Emit code to perform this initialization but once.  */
8692       tree if_stmt;
8693       tree then_clause;
8694       tree assignment;
8695       tree guard;
8696       tree guard_init;
8697
8698       /* Emit code to perform this initialization but once.  This code
8699          looks like:
8700
8701            static int guard = 0;
8702            if (!guard) {
8703              // Do initialization.
8704              guard = 1;
8705              // Register variable for destruction at end of program.
8706            }
8707
8708          Note that the `temp' variable is only set to 1 *after* the
8709          initialization is complete.  This ensures that an exception,
8710          thrown during the construction, will cause the variable to
8711          reinitialized when we pass through this code again, as per:
8712
8713            [stmt.dcl]
8714
8715            If the initialization exits by throwing an exception, the
8716            initialization is not complete, so it will be tried again
8717            the next time control enters the declaration.
8718
8719          In theory, this process should be thread-safe, too; multiple
8720          threads should not be able to initialize the variable more
8721          than once.  We don't yet attempt to ensure thread-safety.  */
8722
8723       /* Create the guard variable.  */
8724       guard = get_guard (decl);
8725
8726       /* Begin the conditional initialization.  */
8727       if_stmt = begin_if_stmt ();
8728       finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
8729       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8730
8731       /* Do the initialization itself.  */
8732       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8733           || (init && TREE_CODE (init) == TREE_LIST))
8734         assignment = build_aggr_init (decl, init, 0);
8735       else if (init)
8736         /* The initialization we're doing here is just a bitwise
8737            copy.  */
8738         assignment = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
8739       else
8740         assignment = NULL_TREE;
8741
8742       /* Once the assignment is complete, set TEMP to 1.  Since the
8743          construction of the static object is complete at this point,
8744          we want to make sure TEMP is set to 1 even if a temporary
8745          constructed during the initialization throws an exception
8746          when it is destroyed.  So, we combine the initialization and
8747          the assignment to TEMP into a single expression, ensuring
8748          that when we call finish_expr_stmt the cleanups will not be
8749          run until after TEMP is set to 1.  */
8750       guard_init = set_guard (guard);
8751       if (assignment)
8752         {
8753           assignment = tree_cons (NULL_TREE, assignment,
8754                                   build_tree_list (NULL_TREE,
8755                                                    guard_init));
8756           assignment = build_compound_expr (assignment);
8757         }
8758       else
8759         assignment = guard_init;
8760       finish_expr_stmt (assignment);
8761
8762       /* Use atexit to register a function for destroying this static
8763          variable.  */
8764       register_dtor_fn (decl);
8765
8766       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8767       finish_then_clause (if_stmt);
8768       finish_if_stmt ();
8769     }
8770   else
8771     static_aggregates = tree_cons (init, decl, static_aggregates);
8772 }
8773
8774 /* Finish the declaration of a catch-parameter.  */
8775
8776 tree
8777 start_handler_parms (declspecs, declarator)
8778      tree declspecs;
8779      tree declarator;
8780 {
8781   tree decl;
8782   if (declspecs)
8783     {
8784       decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8785                              1, NULL_TREE);
8786       if (decl == NULL_TREE)
8787         error ("invalid catch parameter");
8788     }
8789   else
8790     decl = NULL_TREE;
8791
8792   return decl;
8793 }
8794
8795 \f
8796 /* Make TYPE a complete type based on INITIAL_VALUE.
8797    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8798    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
8799
8800 int
8801 complete_array_type (type, initial_value, do_default)
8802      tree type, initial_value;
8803      int do_default;
8804 {
8805   register tree maxindex = NULL_TREE;
8806   int value = 0;
8807
8808   if (initial_value)
8809     {
8810       /* An array of character type can be initialized from a
8811          brace-enclosed string constant.  */
8812       if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))
8813           && TREE_CODE (initial_value) == CONSTRUCTOR
8814           && CONSTRUCTOR_ELTS (initial_value)
8815           && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value)))
8816               == STRING_CST)
8817           && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value)) == NULL_TREE)
8818         initial_value = TREE_VALUE (CONSTRUCTOR_ELTS (initial_value));
8819
8820       /* Note MAXINDEX is really the maximum index, one less than the
8821          size.  */
8822       if (TREE_CODE (initial_value) == STRING_CST)
8823         {
8824           int eltsize
8825             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8826           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8827                                    / eltsize) - 1, 0);
8828         }
8829       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8830         {
8831           tree elts = CONSTRUCTOR_ELTS (initial_value);
8832
8833           maxindex = ssize_int (-1);
8834           for (; elts; elts = TREE_CHAIN (elts))
8835             {
8836               if (TREE_PURPOSE (elts))
8837                 maxindex = TREE_PURPOSE (elts);
8838               else
8839                 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
8840             }
8841           maxindex = copy_node (maxindex);
8842         }
8843       else
8844         {
8845           /* Make an error message unless that happened already.  */
8846           if (initial_value != error_mark_node)
8847             value = 1;
8848           else
8849             initial_value = NULL_TREE;
8850
8851           /* Prevent further error messages.  */
8852           maxindex = build_int_2 (0, 0);
8853         }
8854     }
8855
8856   if (!maxindex)
8857     {
8858       if (do_default)
8859         maxindex = build_int_2 (0, 0);
8860       value = 2;
8861     }
8862
8863   if (maxindex)
8864     {
8865       tree itype;
8866       tree domain;
8867
8868       domain = build_index_type (maxindex);
8869       TYPE_DOMAIN (type) = domain;
8870
8871       if (! TREE_TYPE (maxindex))
8872         TREE_TYPE (maxindex) = domain;
8873       if (initial_value)
8874         itype = TREE_TYPE (initial_value);
8875       else
8876         itype = NULL;
8877       if (itype && !TYPE_DOMAIN (itype))
8878         TYPE_DOMAIN (itype) = domain;
8879       /* The type of the main variant should never be used for arrays
8880          of different sizes.  It should only ever be completed with the
8881          size of the array.  */
8882       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8883         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8884     }
8885
8886   /* Lay out the type now that we can get the real answer.  */
8887
8888   layout_type (type);
8889
8890   return value;
8891 }
8892 \f
8893 /* Return zero if something is declared to be a member of type
8894    CTYPE when in the context of CUR_TYPE.  STRING is the error
8895    message to print in that case.  Otherwise, quietly return 1.  */
8896
8897 static int
8898 member_function_or_else (ctype, cur_type, flags)
8899      tree ctype, cur_type;
8900      enum overload_flags flags;
8901 {
8902   if (ctype && ctype != cur_type)
8903     {
8904       if (flags == DTOR_FLAG)
8905         cp_error ("destructor for alien class `%T' cannot be a member",
8906                   ctype);
8907       else
8908         cp_error ("constructor for alien class `%T' cannot be a member",
8909                   ctype);
8910       return 0;
8911     }
8912   return 1;
8913 }
8914 \f
8915 /* Subroutine of `grokdeclarator'.  */
8916
8917 /* Generate errors possibly applicable for a given set of specifiers.
8918    This is for ARM $7.1.2.  */
8919
8920 static void
8921 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8922      tree object;
8923      const char *type;
8924      int virtualp, quals, friendp, raises, inlinep;
8925 {
8926   if (virtualp)
8927     cp_error ("`%D' declared as a `virtual' %s", object, type);
8928   if (inlinep)
8929     cp_error ("`%D' declared as an `inline' %s", object, type);
8930   if (quals)
8931     cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8932               object, type);
8933   if (friendp)
8934     cp_error_at ("`%D' declared as a friend", object);
8935   if (raises)
8936     cp_error_at ("`%D' declared with an exception specification", object);
8937 }
8938
8939 /* CTYPE is class type, or null if non-class.
8940    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8941    or METHOD_TYPE.
8942    DECLARATOR is the function's name.
8943    VIRTUALP is truthvalue of whether the function is virtual or not.
8944    FLAGS are to be passed through to `grokclassfn'.
8945    QUALS are qualifiers indicating whether the function is `const'
8946    or `volatile'.
8947    RAISES is a list of exceptions that this function can raise.
8948    CHECK is 1 if we must find this method in CTYPE, 0 if we should
8949    not look, and -1 if we should not call `grokclassfn' at all.
8950
8951    Returns `NULL_TREE' if something goes wrong, after issuing
8952    applicable error messages.  */
8953
8954 static tree
8955 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8956             raises, check, friendp, publicp, inlinep, funcdef_flag,
8957             template_count, in_namespace)
8958      tree ctype, type;
8959      tree declarator;
8960      tree orig_declarator;
8961      int virtualp;
8962      enum overload_flags flags;
8963      tree quals, raises;
8964      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8965      tree in_namespace;
8966 {
8967   tree cname, decl;
8968   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8969   int has_default_arg = 0;
8970   tree t;
8971
8972   if (ctype)
8973     cname = TREE_CODE (TYPE_NAME (ctype)) == TYPE_DECL
8974       ? TYPE_IDENTIFIER (ctype) : TYPE_NAME (ctype);
8975   else
8976     cname = NULL_TREE;
8977
8978   if (raises)
8979     {
8980       type = build_exception_variant (type, raises);
8981     }
8982
8983   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8984   /* Propagate volatile out from type to decl. */
8985   if (TYPE_VOLATILE (type))
8986     TREE_THIS_VOLATILE (decl) = 1;
8987
8988   /* If this decl has namespace scope, set that up.  */
8989   if (in_namespace)
8990     set_decl_namespace (decl, in_namespace, friendp);
8991   else if (!ctype)
8992     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8993
8994   /* `main' and builtins have implicit 'C' linkage.  */
8995   if ((MAIN_NAME_P (declarator)
8996        || (IDENTIFIER_LENGTH (declarator) > 10
8997            && IDENTIFIER_POINTER (declarator)[0] == '_'
8998            && IDENTIFIER_POINTER (declarator)[1] == '_'
8999            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
9000       && current_lang_name == lang_name_cplusplus
9001       && ctype == NULL_TREE
9002       /* NULL_TREE means global namespace.  */
9003       && DECL_CONTEXT (decl) == NULL_TREE)
9004     DECL_LANGUAGE (decl) = lang_c;
9005
9006   /* Should probably propagate const out from type to decl I bet (mrs).  */
9007   if (staticp)
9008     {
9009       DECL_STATIC_FUNCTION_P (decl) = 1;
9010       DECL_CONTEXT (decl) = ctype;
9011     }
9012
9013   if (ctype)
9014     DECL_CONTEXT (decl) = ctype;
9015
9016   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
9017     {
9018       if (processing_template_decl)
9019         error ("cannot declare `::main' to be a template");
9020       if (inlinep)
9021         error ("cannot declare `::main' to be inline");
9022       if (!publicp)
9023         error ("cannot declare `::main' to be static");
9024       if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
9025                         integer_type_node))
9026         error ("`main' must return `int'");
9027       inlinep = 0;
9028       publicp = 1;
9029     }
9030
9031   /* Members of anonymous types and local classes have no linkage; make
9032      them internal.  */
9033   if (ctype && (ANON_AGGRNAME_P (TYPE_IDENTIFIER (ctype))
9034                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
9035     publicp = 0;
9036
9037   if (publicp)
9038     {
9039       /* [basic.link]: A name with no linkage (notably, the name of a class
9040          or enumeration declared in a local scope) shall not be used to
9041          declare an entity with linkage.
9042
9043          Only check this for public decls for now.  */
9044       t = no_linkage_check (TREE_TYPE (decl));
9045       if (t)
9046         {
9047           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
9048             {
9049               if (DECL_EXTERN_C_P (decl))
9050                 /* Allow this; it's pretty common in C.  */;
9051               else
9052                 cp_pedwarn ("non-local function `%#D' uses anonymous type",
9053                             decl);
9054             }
9055           else
9056             cp_pedwarn ("non-local function `%#D' uses local type `%T'",
9057                         decl, t);
9058         }
9059     }
9060
9061   TREE_PUBLIC (decl) = publicp;
9062   if (! publicp)
9063     {
9064       DECL_INTERFACE_KNOWN (decl) = 1;
9065       DECL_NOT_REALLY_EXTERN (decl) = 1;
9066     }
9067
9068   if (inlinep)
9069     DECL_THIS_INLINE (decl) = DECL_INLINE (decl) = 1;
9070
9071   DECL_EXTERNAL (decl) = 1;
9072   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
9073     {
9074       cp_error ("%smember function `%D' cannot have `%T' method qualifier",
9075                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
9076       quals = NULL_TREE;
9077     }
9078
9079   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
9080     grok_op_properties (decl, virtualp, check < 0);
9081
9082   if (ctype && decl_function_context (decl))
9083     DECL_NO_STATIC_CHAIN (decl) = 1;
9084
9085   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
9086     if (TREE_PURPOSE (t)
9087         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
9088       {
9089         has_default_arg = 1;
9090         break;
9091       }
9092
9093   if (friendp
9094       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
9095     {
9096       if (funcdef_flag)
9097         cp_error
9098           ("defining explicit specialization `%D' in friend declaration",
9099            orig_declarator);
9100       else
9101         {
9102           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
9103             {
9104               /* Something like `template <class T> friend void f<T>()'.  */
9105               cp_error ("invalid use of template-id `%D' in declaration of primary template",
9106                         orig_declarator);
9107               return NULL_TREE;
9108             }
9109
9110
9111           /* A friend declaration of the form friend void f<>().  Record
9112              the information in the TEMPLATE_ID_EXPR.  */
9113           SET_DECL_IMPLICIT_INSTANTIATION (decl);
9114           DECL_TEMPLATE_INFO (decl)
9115             = tree_cons (TREE_OPERAND (orig_declarator, 0),
9116                          TREE_OPERAND (orig_declarator, 1),
9117                          NULL_TREE);
9118
9119           if (has_default_arg)
9120             {
9121               cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
9122                         decl);
9123               return NULL_TREE;
9124             }
9125
9126           if (inlinep)
9127             {
9128               cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
9129                         decl);
9130               return NULL_TREE;
9131             }
9132         }
9133     }
9134
9135   if (has_default_arg)
9136     add_defarg_fn (decl);
9137
9138   /* Plain overloading: will not be grok'd by grokclassfn.  */
9139   if (! ctype && ! processing_template_decl
9140       && !DECL_EXTERN_C_P (decl)
9141       && (! DECL_USE_TEMPLATE (decl) || name_mangling_version < 1))
9142     set_mangled_name_for_decl (decl);
9143
9144   if (funcdef_flag)
9145     /* Make the init_value nonzero so pushdecl knows this is not
9146        tentative.  error_mark_node is replaced later with the BLOCK.  */
9147     DECL_INITIAL (decl) = error_mark_node;
9148
9149   if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
9150     TREE_NOTHROW (decl) = 1;
9151
9152   /* Caller will do the rest of this.  */
9153   if (check < 0)
9154     return decl;
9155
9156   if (flags == NO_SPECIAL && ctype && constructor_name (cname) == declarator)
9157     DECL_CONSTRUCTOR_P (decl) = 1;
9158
9159   /* Function gets the ugly name, field gets the nice one.  This call
9160      may change the type of the function (because of default
9161      parameters)!  */
9162   if (ctype != NULL_TREE)
9163     grokclassfn (ctype, decl, flags, quals);
9164
9165   decl = check_explicit_specialization (orig_declarator, decl,
9166                                         template_count,
9167                                         2 * (funcdef_flag != 0) +
9168                                         4 * (friendp != 0));
9169   if (decl == error_mark_node)
9170     return NULL_TREE;
9171
9172   if (ctype != NULL_TREE
9173       && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
9174       && check)
9175     {
9176       tree old_decl;
9177
9178       old_decl = check_classfn (ctype, decl);
9179
9180       if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
9181         /* Because grokfndecl is always supposed to return a
9182            FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
9183            here.  We depend on our callers to figure out that its
9184            really a template that's being returned.  */
9185         old_decl = DECL_TEMPLATE_RESULT (old_decl);
9186
9187       if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
9188           && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
9189         {
9190           /* Remove the `this' parm added by grokclassfn.
9191              XXX Isn't this done in start_function, too?  */
9192           revert_static_member_fn (decl);
9193           last_function_parms = TREE_CHAIN (last_function_parms);
9194         }
9195       if (old_decl && DECL_ARTIFICIAL (old_decl))
9196         cp_error ("definition of implicitly-declared `%D'", old_decl);
9197
9198       if (old_decl)
9199         {
9200           /* Since we've smashed OLD_DECL to its
9201              DECL_TEMPLATE_RESULT, we must do the same to DECL.  */
9202           if (TREE_CODE (decl) == TEMPLATE_DECL)
9203             decl = DECL_TEMPLATE_RESULT (decl);
9204
9205           /* Attempt to merge the declarations.  This can fail, in
9206              the case of some illegal specialization declarations.  */
9207           if (!duplicate_decls (decl, old_decl))
9208             cp_error ("no `%#D' member function declared in class `%T'",
9209                       decl, ctype);
9210           return old_decl;
9211         }
9212     }
9213
9214   if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
9215     return NULL_TREE;
9216
9217   if (ctype == NULL_TREE || check)
9218     return decl;
9219
9220   if (virtualp)
9221     {
9222       DECL_VIRTUAL_P (decl) = 1;
9223       if (DECL_VINDEX (decl) == NULL_TREE)
9224         DECL_VINDEX (decl) = error_mark_node;
9225       IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
9226     }
9227
9228   return decl;
9229 }
9230
9231 static tree
9232 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
9233      tree type;
9234      tree declarator;
9235      RID_BIT_TYPE *specbits_in;
9236      int initialized;
9237      int constp;
9238      tree in_namespace;
9239 {
9240   tree decl;
9241   RID_BIT_TYPE specbits;
9242
9243   specbits = *specbits_in;
9244
9245   if (TREE_CODE (type) == OFFSET_TYPE)
9246     {
9247       /* If you declare a static member so that it
9248          can be initialized, the code will reach here.  */
9249       tree basetype = TYPE_OFFSET_BASETYPE (type);
9250       type = TREE_TYPE (type);
9251       decl = build_lang_decl (VAR_DECL, declarator, type);
9252       DECL_CONTEXT (decl) = basetype;
9253       /* DECL_ASSEMBLER_NAME is needed only for full-instantiated
9254          templates.  */
9255       if (!uses_template_parms (decl))
9256         {
9257           if (flag_new_abi)
9258             DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
9259           else
9260             DECL_ASSEMBLER_NAME (decl) = build_static_name (basetype,
9261                                                             declarator);
9262         }
9263     }
9264   else
9265     {
9266       tree context;
9267
9268       if (in_namespace)
9269         context = in_namespace;
9270       else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
9271         context = current_namespace;
9272       else
9273         context = NULL_TREE;
9274
9275       if (processing_template_decl && context)
9276         /* For global variables, declared in a template, we need the
9277            full lang_decl.  */
9278         decl = build_lang_decl (VAR_DECL, declarator, type);
9279       else
9280         decl = build_decl (VAR_DECL, declarator, type);
9281
9282       if (context)
9283         set_decl_namespace (decl, context, 0);
9284
9285       context = DECL_CONTEXT (decl);
9286       if (declarator && context && current_lang_name != lang_name_c)
9287         {
9288           if (flag_new_abi)
9289             DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
9290           else
9291             DECL_ASSEMBLER_NAME (decl)
9292               = build_static_name (context, declarator);
9293         }
9294     }
9295
9296   if (in_namespace)
9297     set_decl_namespace (decl, in_namespace, 0);
9298
9299   if (RIDBIT_SETP (RID_EXTERN, specbits))
9300     {
9301       DECL_THIS_EXTERN (decl) = 1;
9302       DECL_EXTERNAL (decl) = !initialized;
9303     }
9304
9305   /* In class context, static means one per class,
9306      public access, and static storage.  */
9307   if (DECL_CLASS_SCOPE_P (decl))
9308     {
9309       TREE_PUBLIC (decl) = 1;
9310       TREE_STATIC (decl) = 1;
9311       DECL_EXTERNAL (decl) = 0;
9312     }
9313   /* At top level, either `static' or no s.c. makes a definition
9314      (perhaps tentative), and absence of `static' makes it public.  */
9315   else if (toplevel_bindings_p ())
9316     {
9317       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
9318                             && (DECL_THIS_EXTERN (decl) || ! constp));
9319       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
9320     }
9321   /* Not at top level, only `static' makes a static definition.  */
9322   else
9323     {
9324       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
9325       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
9326     }
9327
9328   if (TREE_PUBLIC (decl))
9329     {
9330       /* [basic.link]: A name with no linkage (notably, the name of a class
9331          or enumeration declared in a local scope) shall not be used to
9332          declare an entity with linkage.
9333
9334          Only check this for public decls for now.  */
9335       tree t = no_linkage_check (TREE_TYPE (decl));
9336       if (t)
9337         {
9338           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
9339             /* Ignore for now; `enum { foo } e' is pretty common.  */;
9340           else
9341             cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
9342                         decl, t);
9343         }
9344     }
9345
9346   return decl;
9347 }
9348
9349 /* Create and return a canonical pointer to member function type, for
9350    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
9351
9352 tree
9353 build_ptrmemfunc_type (type)
9354      tree type;
9355 {
9356   tree fields[4];
9357   tree t;
9358   tree u;
9359   tree unqualified_variant = NULL_TREE;
9360
9361   /* If a canonical type already exists for this type, use it.  We use
9362      this method instead of type_hash_canon, because it only does a
9363      simple equality check on the list of field members.  */
9364
9365   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
9366     return t;
9367
9368   /* Make sure that we always have the unqualified pointer-to-member
9369      type first.  */
9370   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9371     unqualified_variant
9372       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
9373
9374   t = make_aggr_type (RECORD_TYPE);
9375   /* Let the front-end know this is a pointer to member function...  */
9376   TYPE_PTRMEMFUNC_FLAG (t) = 1;
9377   /* ... and not really an aggregate.  */
9378   SET_IS_AGGR_TYPE (t, 0);
9379
9380   if (!flag_new_abi)
9381     {
9382       u = make_aggr_type (UNION_TYPE);
9383       SET_IS_AGGR_TYPE (u, 0);
9384       fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9385       fields[1] = build_decl (FIELD_DECL, delta2_identifier,
9386                               delta_type_node);
9387       finish_builtin_type (u, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9388       TYPE_NAME (u) = NULL_TREE;
9389
9390       fields[0] = build_decl (FIELD_DECL, delta_identifier,
9391                               delta_type_node);
9392       fields[1] = build_decl (FIELD_DECL, index_identifier,
9393                               delta_type_node);
9394       fields[2] = build_decl (FIELD_DECL, pfn_or_delta2_identifier, u);
9395       finish_builtin_type (t, "__ptrmemfunc_type", fields, 2, ptr_type_node);
9396     }
9397   else
9398     {
9399       fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9400       fields[1] = build_decl (FIELD_DECL, delta_identifier,
9401                               delta_type_node);
9402       finish_builtin_type (t, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9403     }
9404
9405   /* Zap out the name so that the back-end will give us the debugging
9406      information for this anonymous RECORD_TYPE.  */
9407   TYPE_NAME (t) = NULL_TREE;
9408
9409   /* If this is not the unqualified form of this pointer-to-member
9410      type, set the TYPE_MAIN_VARIANT for this type to be the
9411      unqualified type.  Since they are actually RECORD_TYPEs that are
9412      not variants of each other, we must do this manually.  */
9413   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9414     {
9415       t = build_qualified_type (t, CP_TYPE_QUALS (type));
9416       TYPE_MAIN_VARIANT (t) = unqualified_variant;
9417       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
9418       TYPE_NEXT_VARIANT (unqualified_variant) = t;
9419     }
9420
9421   /* Cache this pointer-to-member type so that we can find it again
9422      later.  */
9423   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
9424
9425   /* Seems to be wanted.  */
9426   CLASSTYPE_GOT_SEMICOLON (t) = 1;
9427
9428   return t;
9429 }
9430
9431 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9432    Check to see that the definition is valid.  Issue appropriate error
9433    messages.  Return 1 if the definition is particularly bad, or 0
9434    otherwise.  */
9435
9436 int
9437 check_static_variable_definition (decl, type)
9438      tree decl;
9439      tree type;
9440 {
9441   /* Motion 10 at San Diego: If a static const integral data member is
9442      initialized with an integral constant expression, the initializer
9443      may appear either in the declaration (within the class), or in
9444      the definition, but not both.  If it appears in the class, the
9445      member is a member constant.  The file-scope definition is always
9446      required.  */
9447   if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
9448     {
9449       cp_error ("invalid in-class initialization of static data member of non-integral type `%T'",
9450                 type);
9451       /* If we just return the declaration, crashes will sometimes
9452          occur.  We therefore return void_type_node, as if this was a
9453          friend declaration, to cause callers to completely ignore
9454          this declaration.  */
9455       return 1;
9456     }
9457   else if (!CP_TYPE_CONST_P (type))
9458     cp_error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9459               decl);
9460   else if (pedantic && !INTEGRAL_TYPE_P (type))
9461     cp_pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
9462
9463   return 0;
9464 }
9465
9466 /* Given the SIZE (i.e., number of elements) in an array, compute an
9467    appropriate index type for the array.  If non-NULL, NAME is the
9468    name of the thing being declared.  */
9469
9470 tree
9471 compute_array_index_type (name, size)
9472      tree name;
9473      tree size;
9474 {
9475   tree itype;
9476
9477   /* The size might be the result of a cast. */
9478   STRIP_TYPE_NOPS (size);
9479
9480   /* It might be a const variable or enumeration constant.  */
9481   size = decl_constant_value (size);
9482
9483   /* If this involves a template parameter, it will be a constant at
9484      instantiation time, but we don't know what the value is yet.
9485      Even if no template parameters are involved, we may an expression
9486      that is not a constant; we don't even simplify `1 + 2' when
9487      processing a template.  */
9488   if (processing_template_decl)
9489     {
9490       /* Resolve a qualified reference to an enumerator or static
9491          const data member of ours.  */
9492       if (TREE_CODE (size) == SCOPE_REF
9493           && TREE_OPERAND (size, 0) == current_class_type)
9494         {
9495           tree t = lookup_field (current_class_type,
9496                                  TREE_OPERAND (size, 1), 0, 0);
9497           if (t)
9498             size = t;
9499         }
9500
9501       return build_index_type (build_min (MINUS_EXPR, sizetype,
9502                                           size, integer_one_node));
9503     }
9504
9505   /* The array bound must be an integer type.  */
9506   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9507       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
9508       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
9509     {
9510       if (name)
9511         cp_error ("size of array `%D' has non-integer type", name);
9512       else
9513         cp_error ("size of array has non-integer type");
9514       size = integer_one_node;
9515     }
9516
9517   /* Normally, the array-bound will be a constant.  */
9518   if (TREE_CODE (size) == INTEGER_CST)
9519     {
9520       /* Check to see if the array bound overflowed.  Make that an
9521          error, no matter how generous we're being.  */
9522       int old_flag_pedantic_errors = flag_pedantic_errors;
9523       int old_pedantic = pedantic;
9524       pedantic = flag_pedantic_errors = 1;
9525       constant_expression_warning (size);
9526       pedantic = old_pedantic;
9527       flag_pedantic_errors = old_flag_pedantic_errors;
9528
9529       /* An array must have a positive number of elements.  */
9530       if (INT_CST_LT (size, integer_zero_node))
9531         {
9532           if (name)
9533             cp_error ("size of array `%D' is negative", name);
9534           else
9535             cp_error ("size of array is negative");
9536           size = integer_one_node;
9537         }
9538       /* Except that an extension we allow zero-sized arrays.  We
9539          always allow them in system headers because glibc uses
9540          them.  */
9541       else if (integer_zerop (size) && pedantic && !in_system_header)
9542         {
9543           if (name)
9544             cp_pedwarn ("ISO C++ forbids zero-size array `%D'", name);
9545           else
9546             cp_pedwarn ("ISO C++ forbids zero-size array");
9547         }
9548     }
9549   else if (TREE_CONSTANT (size))
9550     {
9551       /* `(int) &fn' is not a valid array bound.  */
9552       if (name)
9553         cp_error ("size of array `%D' is not an integral constant-expression",
9554                   name);
9555       else
9556         cp_error ("size of array is not an integral constant-expression");
9557     }
9558
9559   /* Compute the index of the largest element in the array.  It is
9560      one less than the number of elements in the array.  */
9561   itype
9562     = fold (cp_build_binary_op (MINUS_EXPR,
9563                                 cp_convert (ssizetype, size),
9564                                 cp_convert (ssizetype,
9565                                             integer_one_node)));
9566
9567   /* Check for variable-sized arrays.  We allow such things as an
9568      extension, even though they are not allowed in ANSI/ISO C++.  */
9569   if (!TREE_CONSTANT (itype))
9570     {
9571       if (pedantic)
9572         {
9573           if (name)
9574             cp_pedwarn ("ISO C++ forbids variable-size array `%D'",
9575                         name);
9576           else
9577             cp_pedwarn ("ISO C++ forbids variable-size array");
9578         }
9579
9580       /* Create a variable-sized array index type.  */
9581       itype = variable_size (itype);
9582     }
9583   /* Make sure that there was no overflow when creating to a signed
9584      index type.  (For example, on a 32-bit machine, an array with
9585      size 2^32 - 1 is too big.)  */
9586   else if (TREE_OVERFLOW (itype))
9587     {
9588       error ("overflow in array dimension");
9589       TREE_OVERFLOW (itype) = 0;
9590     }
9591
9592   /* Create and return the appropriate index type.  */
9593   return build_index_type (itype);
9594 }
9595
9596 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9597    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
9598    with this type.  */
9599
9600 static tree
9601 create_array_type_for_decl (name, type, size)
9602      tree name;
9603      tree type;
9604      tree size;
9605 {
9606   tree itype = NULL_TREE;
9607   const char* error_msg;
9608
9609   /* If things have already gone awry, bail now.  */
9610   if (type == error_mark_node || size == error_mark_node)
9611     return error_mark_node;
9612
9613   /* Assume that everything will go OK.  */
9614   error_msg = NULL;
9615
9616   /* There are some types which cannot be array elements.  */
9617   switch (TREE_CODE (type))
9618     {
9619     case VOID_TYPE:
9620       error_msg = "array of void";
9621       break;
9622
9623     case FUNCTION_TYPE:
9624       error_msg = "array of functions";
9625       break;
9626
9627     case REFERENCE_TYPE:
9628       error_msg = "array of references";
9629       break;
9630
9631     case OFFSET_TYPE:
9632       error_msg = "array of data members";
9633       break;
9634
9635     case METHOD_TYPE:
9636       error_msg = "array of function members";
9637       break;
9638
9639     default:
9640       break;
9641     }
9642
9643   /* If something went wrong, issue an error-message and return.  */
9644   if (error_msg)
9645     {
9646       if (name)
9647         cp_error ("declaration of `%D' as %s", name, error_msg);
9648       else
9649         cp_error ("creating %s", error_msg);
9650
9651       return error_mark_node;
9652     }
9653
9654   /* [dcl.array]
9655
9656      The constant expressions that specify the bounds of the arrays
9657      can be omitted only for the first member of the sequence.  */
9658   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9659     {
9660       cp_error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9661                 name);
9662
9663       return error_mark_node;
9664     }
9665
9666   /* Figure out the index type for the array.  */
9667   if (size)
9668     itype = compute_array_index_type (name, size);
9669
9670   return build_cplus_array_type (type, itype);
9671 }
9672
9673 /* Check that it's OK to declare a function with the indicated TYPE.
9674    SFK indicates the kind of special function (if any) that this
9675    function is.  CTYPE is the class of which this function is a
9676    member.  OPTYPE is the type given in a conversion operator
9677    declaration.  Returns the actual return type of the function; that
9678    may be different than TYPE if an error occurs, or for certain
9679    special functions.  */
9680
9681 static tree
9682 check_special_function_return_type (sfk, type, ctype, optype)
9683      special_function_kind sfk;
9684      tree type;
9685      tree ctype;
9686      tree optype;
9687 {
9688   switch (sfk)
9689     {
9690     case sfk_constructor:
9691       if (type)
9692         cp_error ("return type specification for constructor invalid");
9693
9694       /* In the old ABI, we return `this'; in the new ABI we don't
9695          bother.  */
9696       type = flag_new_abi ? void_type_node : build_pointer_type (ctype);
9697       break;
9698
9699     case sfk_destructor:
9700       if (type)
9701         cp_error ("return type specification for destructor invalid");
9702       type = void_type_node;
9703       break;
9704
9705     case sfk_conversion:
9706       if (type && !same_type_p (type, optype))
9707         cp_error ("operator `%T' declared to return `%T'", optype, type);
9708       else if (type)
9709         cp_pedwarn ("return type specified for `operator %T'",  optype);
9710       type = optype;
9711       break;
9712
9713     default:
9714       my_friendly_abort (20000408);
9715       break;
9716     }
9717
9718   return type;
9719 }
9720
9721 /* Given declspecs and a declarator,
9722    determine the name and type of the object declared
9723    and construct a ..._DECL node for it.
9724    (In one case we can return a ..._TYPE node instead.
9725     For invalid input we sometimes return 0.)
9726
9727    DECLSPECS is a chain of tree_list nodes whose value fields
9728     are the storage classes and type specifiers.
9729
9730    DECL_CONTEXT says which syntactic context this declaration is in:
9731      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9732      FUNCDEF for a function definition.  Like NORMAL but a few different
9733       error messages in each case.  Return value may be zero meaning
9734       this definition is too screwy to try to parse.
9735      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
9736       handle member functions (which have FIELD context).
9737       Return value may be zero meaning this definition is too screwy to
9738       try to parse.
9739      PARM for a parameter declaration (either within a function prototype
9740       or before a function body).  Make a PARM_DECL, or return void_type_node.
9741      CATCHPARM for a parameter declaration before a catch clause.
9742      TYPENAME if for a typename (in a cast or sizeof).
9743       Don't make a DECL node; just return the ..._TYPE node.
9744      FIELD for a struct or union field; make a FIELD_DECL.
9745      BITFIELD for a field with specified width.
9746    INITIALIZED is 1 if the decl has an initializer.
9747
9748    ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
9749    normal attributes in TREE_PURPOSE, or NULL_TREE.
9750
9751    In the TYPENAME case, DECLARATOR is really an abstract declarator.
9752    It may also be so in the PARM case, for a prototype where the
9753    argument type is specified but not the name.
9754
9755    This function is where the complicated C meanings of `static'
9756    and `extern' are interpreted.
9757
9758    For C++, if there is any monkey business to do, the function which
9759    calls this one must do it, i.e., prepending instance variables,
9760    renaming overloaded function names, etc.
9761
9762    Note that for this C++, it is an error to define a method within a class
9763    which does not belong to that class.
9764
9765    Except in the case where SCOPE_REFs are implicitly known (such as
9766    methods within a class being redundantly qualified),
9767    declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9768    (class_name::decl_name).  The caller must also deal with this.
9769
9770    If a constructor or destructor is seen, and the context is FIELD,
9771    then the type gains the attribute TREE_HAS_x.  If such a declaration
9772    is erroneous, NULL_TREE is returned.
9773
9774    QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
9775    function, these are the qualifiers to give to the `this' pointer. We
9776    apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9777
9778    May return void_type_node if the declarator turned out to be a friend.
9779    See grokfield for details.  */
9780
9781 tree
9782 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9783      tree declspecs;
9784      tree declarator;
9785      enum decl_context decl_context;
9786      int initialized;
9787      tree attrlist;
9788 {
9789   RID_BIT_TYPE specbits;
9790   int nclasses = 0;
9791   tree spec;
9792   tree type = NULL_TREE;
9793   int longlong = 0;
9794   int constp;
9795   int restrictp;
9796   int volatilep;
9797   int type_quals;
9798   int virtualp, explicitp, friendp, inlinep, staticp;
9799   int explicit_int = 0;
9800   int explicit_char = 0;
9801   int defaulted_int = 0;
9802   tree typedef_decl = NULL_TREE;
9803   const char *name;
9804   tree typedef_type = NULL_TREE;
9805   int funcdef_flag = 0;
9806   enum tree_code innermost_code = ERROR_MARK;
9807   int bitfield = 0;
9808 #if 0
9809   /* See the code below that used this.  */
9810   tree decl_machine_attr = NULL_TREE;
9811 #endif
9812   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9813      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9814   tree init = NULL_TREE;
9815
9816   /* Keep track of what sort of function is being processed
9817      so that we can warn about default return values, or explicit
9818      return values which do not match prescribed defaults.  */
9819   special_function_kind sfk = sfk_none;
9820
9821   tree dname = NULL_TREE;
9822   tree ctype = current_class_type;
9823   tree ctor_return_type = NULL_TREE;
9824   enum overload_flags flags = NO_SPECIAL;
9825   tree quals = NULL_TREE;
9826   tree raises = NULL_TREE;
9827   int template_count = 0;
9828   tree in_namespace = NULL_TREE;
9829   tree inner_attrs;
9830   int ignore_attrs;
9831
9832   RIDBIT_RESET_ALL (specbits);
9833   if (decl_context == FUNCDEF)
9834     funcdef_flag = 1, decl_context = NORMAL;
9835   else if (decl_context == MEMFUNCDEF)
9836     funcdef_flag = -1, decl_context = FIELD;
9837   else if (decl_context == BITFIELD)
9838     bitfield = 1, decl_context = FIELD;
9839
9840   /* Look inside a declarator for the name being declared
9841      and get it as a string, for an error message.  */
9842   {
9843     tree *next = &declarator;
9844     register tree decl;
9845     name = NULL;
9846
9847     while (next && *next)
9848       {
9849         decl = *next;
9850         switch (TREE_CODE (decl))
9851           {
9852           case TREE_LIST:
9853             /* For attributes.  */
9854             next = &TREE_VALUE (decl);
9855             break;
9856
9857           case COND_EXPR:
9858             ctype = NULL_TREE;
9859             next = &TREE_OPERAND (decl, 0);
9860             break;
9861
9862           case BIT_NOT_EXPR:    /* For C++ destructors!  */
9863             {
9864               tree name = TREE_OPERAND (decl, 0);
9865               tree rename = NULL_TREE;
9866
9867               my_friendly_assert (flags == NO_SPECIAL, 152);
9868               flags = DTOR_FLAG;
9869               sfk = sfk_destructor;
9870               if (TREE_CODE (name) == TYPE_DECL)
9871                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9872               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9873               if (ctype == NULL_TREE)
9874                 {
9875                   if (current_class_type == NULL_TREE)
9876                     {
9877                       error ("destructors must be member functions");
9878                       flags = NO_SPECIAL;
9879                     }
9880                   else
9881                     {
9882                       tree t = constructor_name (current_class_name);
9883                       if (t != name)
9884                         rename = t;
9885                     }
9886                 }
9887               else
9888                 {
9889                   tree t = constructor_name (ctype);
9890                   if (t != name)
9891                     rename = t;
9892                 }
9893
9894               if (rename)
9895                 {
9896                   cp_error ("destructor `%T' must match class name `%T'",
9897                             name, rename);
9898                   TREE_OPERAND (decl, 0) = rename;
9899                 }
9900               next = &name;
9901             }
9902             break;
9903
9904           case ADDR_EXPR:       /* C++ reference declaration */
9905             /* Fall through. */
9906           case ARRAY_REF:
9907           case INDIRECT_REF:
9908             ctype = NULL_TREE;
9909             innermost_code = TREE_CODE (decl);
9910             next = &TREE_OPERAND (decl, 0);
9911             break;
9912
9913           case CALL_EXPR:
9914             if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
9915               {
9916                 /* This is actually a variable declaration using
9917                    constructor syntax.  We need to call start_decl and
9918                    cp_finish_decl so we can get the variable
9919                    initialized...  */
9920
9921                 tree attributes, prefix_attributes;
9922
9923                 *next = TREE_OPERAND (decl, 0);
9924                 init = CALL_DECLARATOR_PARMS (decl);
9925
9926                 if (attrlist)
9927                   {
9928                     attributes = TREE_PURPOSE (attrlist);
9929                     prefix_attributes = TREE_VALUE (attrlist);
9930                   }
9931                 else
9932                   {
9933                     attributes = NULL_TREE;
9934                     prefix_attributes = NULL_TREE;
9935                   }
9936
9937                 decl = start_decl (declarator, declspecs, 1,
9938                                    attributes, prefix_attributes);
9939                 decl_type_access_control (decl);
9940                 if (decl)
9941                   {
9942                     /* Look for __unused__ attribute */
9943                     if (TREE_USED (TREE_TYPE (decl)))
9944                       TREE_USED (decl) = 1;
9945                     finish_decl (decl, init, NULL_TREE);
9946                   }
9947                 else
9948                   cp_error ("invalid declarator");
9949                 return 0;
9950               }
9951             innermost_code = TREE_CODE (decl);
9952             if (decl_context == FIELD && ctype == NULL_TREE)
9953               ctype = current_class_type;
9954             if (ctype
9955                 && TREE_OPERAND (decl, 0)
9956                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9957                     && ((DECL_NAME (TREE_OPERAND (decl, 0))
9958                          == constructor_name_full (ctype))
9959                         || (DECL_NAME (TREE_OPERAND (decl, 0))
9960                             == constructor_name (ctype)))))
9961               TREE_OPERAND (decl, 0) = constructor_name (ctype);
9962             next = &TREE_OPERAND (decl, 0);
9963             decl = *next;
9964             if (ctype != NULL_TREE
9965                 && decl != NULL_TREE && flags != DTOR_FLAG
9966                 && decl == constructor_name (ctype))
9967               {
9968                 sfk = sfk_constructor;
9969                 ctor_return_type = ctype;
9970               }
9971             ctype = NULL_TREE;
9972             break;
9973
9974           case TEMPLATE_ID_EXPR:
9975               {
9976                 tree fns = TREE_OPERAND (decl, 0);
9977
9978                 if (TREE_CODE (fns) == LOOKUP_EXPR)
9979                   fns = TREE_OPERAND (fns, 0);
9980
9981                 dname = fns;
9982                 if (TREE_CODE (dname) == COMPONENT_REF)
9983                   dname = TREE_OPERAND (dname, 1);
9984                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9985                   {
9986                     my_friendly_assert (is_overloaded_fn (dname),
9987                                         19990331);
9988                     dname = DECL_NAME (get_first_fn (dname));
9989                   }
9990               }
9991           /* Fall through. */
9992
9993           case IDENTIFIER_NODE:
9994             if (TREE_CODE (decl) == IDENTIFIER_NODE)
9995               dname = decl;
9996
9997             next = 0;
9998
9999             if (C_IS_RESERVED_WORD (dname))
10000               {
10001                 cp_error ("declarator-id missing; using reserved word `%D'",
10002                           dname);
10003                 name = IDENTIFIER_POINTER (dname);
10004               }
10005             else if (!IDENTIFIER_TYPENAME_P (dname))
10006               name = IDENTIFIER_POINTER (dname);
10007             else
10008               {
10009                 my_friendly_assert (flags == NO_SPECIAL, 154);
10010                 flags = TYPENAME_FLAG;
10011                 ctor_return_type = TREE_TYPE (dname);
10012                 sfk = sfk_conversion;
10013                 if (IDENTIFIER_GLOBAL_VALUE (dname)
10014                     && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (dname))
10015                         == TYPE_DECL))
10016                   name = IDENTIFIER_POINTER (dname);
10017                 else
10018                   name = "<invalid operator>";
10019               }
10020             break;
10021
10022             /* C++ extension */
10023           case SCOPE_REF:
10024             {
10025               /* Perform error checking, and decide on a ctype.  */
10026               tree cname = TREE_OPERAND (decl, 0);
10027               if (cname == NULL_TREE)
10028                 ctype = NULL_TREE;
10029               else if (TREE_CODE (cname) == NAMESPACE_DECL)
10030                 {
10031                   ctype = NULL_TREE;
10032                   in_namespace = TREE_OPERAND (decl, 0);
10033                   TREE_OPERAND (decl, 0) = NULL_TREE;
10034                 }
10035               else if (! is_aggr_type (cname, 1))
10036                 TREE_OPERAND (decl, 0) = NULL_TREE;
10037               /* Must test TREE_OPERAND (decl, 1), in case user gives
10038                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
10039               else if (TREE_OPERAND (decl, 1)
10040                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
10041                 ctype = cname;
10042               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
10043                        || TREE_CODE (cname) == BOUND_TEMPLATE_TEMPLATE_PARM)
10044                 {
10045                   cp_error ("`%T::%D' is not a valid declarator", cname,
10046                             TREE_OPERAND (decl, 1));
10047                   cp_error ("  perhaps you want `typename %T::%D' to make it a type",
10048                             cname, TREE_OPERAND (decl, 1));
10049                   return void_type_node;
10050                 }
10051               else if (ctype == NULL_TREE)
10052                 ctype = cname;
10053               else if (TREE_COMPLEXITY (decl) == current_class_depth)
10054                 TREE_OPERAND (decl, 0) = ctype;
10055               else
10056                 {
10057                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
10058                     {
10059                       cp_error ("type `%T' is not derived from type `%T'",
10060                                 cname, ctype);
10061                       TREE_OPERAND (decl, 0) = NULL_TREE;
10062                     }
10063                   else
10064                     ctype = cname;
10065                 }
10066
10067               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
10068                   && ((DECL_NAME (TREE_OPERAND (decl, 1))
10069                        == constructor_name_full (ctype))
10070                       || (DECL_NAME (TREE_OPERAND (decl, 1))
10071                           == constructor_name (ctype))))
10072                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
10073               next = &TREE_OPERAND (decl, 1);
10074               decl = *next;
10075               if (ctype)
10076                 {
10077                   if (TREE_CODE (decl) == IDENTIFIER_NODE
10078                       && constructor_name (ctype) == decl)
10079                     {
10080                       sfk = sfk_constructor;
10081                       ctor_return_type = ctype;
10082                     }
10083                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
10084                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
10085                            && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
10086                                || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
10087                     {
10088                       sfk = sfk_destructor;
10089                       ctor_return_type = ctype;
10090                       flags = DTOR_FLAG;
10091                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
10092                       next = &TREE_OPERAND (decl, 0);
10093                     }
10094                 }
10095             }
10096             break;
10097
10098           case ERROR_MARK:
10099             next = 0;
10100             break;
10101
10102           case TYPE_DECL:
10103             /* Parse error puts this typespec where
10104                a declarator should go.  */
10105             cp_error ("`%T' specified as declarator-id", DECL_NAME (decl));
10106             if (TREE_TYPE (decl) == current_class_type)
10107               cp_error ("  perhaps you want `%T' for a constructor",
10108                         current_class_name);
10109             dname = DECL_NAME (decl);
10110             name = IDENTIFIER_POINTER (dname);
10111
10112             /* Avoid giving two errors for this.  */
10113             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
10114
10115             declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
10116             *next = dname;
10117             next = 0;
10118             break;
10119
10120           default:
10121             cp_compiler_error ("`%D' as declarator", decl);
10122             return 0; /* We used to do a 155 abort here.  */
10123           }
10124       }
10125   }
10126
10127   /* A function definition's declarator must have the form of
10128      a function declarator.  */
10129
10130   if (funcdef_flag && innermost_code != CALL_EXPR)
10131     return 0;
10132
10133   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
10134       && innermost_code != CALL_EXPR
10135       && ! (ctype && declspecs == NULL_TREE))
10136     {
10137       cp_error ("declaration of `%D' as non-function", dname);
10138       return void_type_node;
10139     }
10140
10141   /* Anything declared one level down from the top level
10142      must be one of the parameters of a function
10143      (because the body is at least two levels down).  */
10144
10145   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
10146      by not allowing C++ class definitions to specify their parameters
10147      with xdecls (must be spec.d in the parmlist).
10148
10149      Since we now wait to push a class scope until we are sure that
10150      we are in a legitimate method context, we must set oldcname
10151      explicitly (since current_class_name is not yet alive).
10152
10153      We also want to avoid calling this a PARM if it is in a namespace.  */
10154
10155   if (decl_context == NORMAL && !toplevel_bindings_p ())
10156     {
10157       struct binding_level *b = current_binding_level;
10158       current_binding_level = b->level_chain;
10159       if (current_binding_level != 0 && toplevel_bindings_p ())
10160         decl_context = PARM;
10161       current_binding_level = b;
10162     }
10163
10164   if (name == NULL)
10165     name = decl_context == PARM ? "parameter" : "type name";
10166
10167   /* Look through the decl specs and record which ones appear.
10168      Some typespecs are defined as built-in typenames.
10169      Others, the ones that are modifiers of other types,
10170      are represented by bits in SPECBITS: set the bits for
10171      the modifiers that appear.  Storage class keywords are also in SPECBITS.
10172
10173      If there is a typedef name or a type, store the type in TYPE.
10174      This includes builtin typedefs such as `int'.
10175
10176      Set EXPLICIT_INT if the type is `int' or `char' and did not
10177      come from a user typedef.
10178
10179      Set LONGLONG if `long' is mentioned twice.
10180
10181      For C++, constructors and destructors have their own fast treatment.  */
10182
10183   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
10184     {
10185       register int i;
10186       register tree id;
10187
10188       /* Certain parse errors slip through.  For example,
10189          `int class;' is not caught by the parser. Try
10190          weakly to recover here.  */
10191       if (TREE_CODE (spec) != TREE_LIST)
10192         return 0;
10193
10194       id = TREE_VALUE (spec);
10195
10196       if (TREE_CODE (id) == IDENTIFIER_NODE)
10197         {
10198           if (id == ridpointers[(int) RID_INT]
10199               || id == ridpointers[(int) RID_CHAR]
10200               || id == ridpointers[(int) RID_BOOL]
10201               || id == ridpointers[(int) RID_WCHAR])
10202             {
10203               if (type)
10204                 {
10205                   if (id == ridpointers[(int) RID_BOOL])
10206                     error ("`bool' is now a keyword");
10207                   else
10208                     cp_error ("extraneous `%T' ignored", id);
10209                 }
10210               else
10211                 {
10212                   if (id == ridpointers[(int) RID_INT])
10213                     explicit_int = 1;
10214                   else if (id == ridpointers[(int) RID_CHAR])
10215                     explicit_char = 1;
10216                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
10217                 }
10218               goto found;
10219             }
10220           /* C++ aggregate types.  */
10221           if (IDENTIFIER_HAS_TYPE_VALUE (id))
10222             {
10223               if (type)
10224                 cp_error ("multiple declarations `%T' and `%T'", type, id);
10225               else
10226                 type = IDENTIFIER_TYPE_VALUE (id);
10227               goto found;
10228             }
10229
10230           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
10231             {
10232               if (ridpointers[i] == id)
10233                 {
10234                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
10235                     {
10236                       if (pedantic && ! in_system_header && warn_long_long)
10237                         pedwarn ("ISO C++ does not support `long long'");
10238                       if (longlong)
10239                         error ("`long long long' is too long for GCC");
10240                       else
10241                         longlong = 1;
10242                     }
10243                   else if (RIDBIT_SETP (i, specbits))
10244                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
10245                   RIDBIT_SET (i, specbits);
10246                   goto found;
10247                 }
10248             }
10249         }
10250       /* C++ aggregate types.  */
10251       else if (TREE_CODE (id) == TYPE_DECL)
10252         {
10253           if (type)
10254             cp_error ("multiple declarations `%T' and `%T'", type,
10255                       TREE_TYPE (id));
10256           else
10257             {
10258               type = TREE_TYPE (id);
10259               TREE_VALUE (spec) = type;
10260             }
10261           goto found;
10262         }
10263       if (type)
10264         error ("two or more data types in declaration of `%s'", name);
10265       else if (TREE_CODE (id) == IDENTIFIER_NODE)
10266         {
10267           register tree t = lookup_name (id, 1);
10268           if (!t || TREE_CODE (t) != TYPE_DECL)
10269             error ("`%s' fails to be a typedef or built in type",
10270                    IDENTIFIER_POINTER (id));
10271           else
10272             {
10273               type = TREE_TYPE (t);
10274 #if 0
10275               /* See the code below that used this.  */
10276               decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
10277 #endif
10278               typedef_decl = t;
10279             }
10280         }
10281       else if (id != error_mark_node)
10282         /* Can't change CLASS nodes into RECORD nodes here!  */
10283         type = id;
10284
10285     found: ;
10286     }
10287
10288   typedef_type = type;
10289
10290   /* No type at all: default to `int', and set DEFAULTED_INT
10291      because it was not a user-defined typedef.  */
10292
10293   if (type == NULL_TREE
10294       && (RIDBIT_SETP (RID_SIGNED, specbits)
10295           || RIDBIT_SETP (RID_UNSIGNED, specbits)
10296           || RIDBIT_SETP (RID_LONG, specbits)
10297           || RIDBIT_SETP (RID_SHORT, specbits)))
10298     {
10299       /* These imply 'int'.  */
10300       type = integer_type_node;
10301       defaulted_int = 1;
10302     }
10303
10304   if (sfk != sfk_none)
10305     type = check_special_function_return_type (sfk, type,
10306                                                ctor_return_type,
10307                                                ctor_return_type);
10308   else if (type == NULL_TREE)
10309     {
10310       int is_main;
10311
10312       explicit_int = -1;
10313
10314           /* We handle `main' specially here, because 'main () { }' is so
10315              common.  With no options, it is allowed.  With -Wreturn-type,
10316              it is a warning.  It is only an error with -pedantic-errors.  */
10317       is_main = (funcdef_flag
10318                  && MAIN_NAME_P (dname)
10319                  && ctype == NULL_TREE
10320                  && in_namespace == NULL_TREE
10321                  && current_namespace == global_namespace);
10322
10323       if (in_system_header || flag_ms_extensions)
10324         /* Allow it, sigh.  */;
10325       else if (pedantic || ! is_main)
10326         cp_pedwarn ("ISO C++ forbids declaration of `%s' with no type",
10327                     name);
10328       else if (warn_return_type)
10329         cp_warning ("ISO C++ forbids declaration of `%s' with no type",
10330                     name);
10331
10332       type = integer_type_node;
10333     }
10334
10335   ctype = NULL_TREE;
10336
10337   /* Now process the modifiers that were specified
10338      and check for invalid combinations.  */
10339
10340   /* Long double is a special combination.  */
10341
10342   if (RIDBIT_SETP (RID_LONG, specbits)
10343       && TYPE_MAIN_VARIANT (type) == double_type_node)
10344     {
10345       RIDBIT_RESET (RID_LONG, specbits);
10346       type = build_qualified_type (long_double_type_node,
10347                                    CP_TYPE_QUALS (type));
10348     }
10349
10350   /* Check all other uses of type modifiers.  */
10351
10352   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10353       || RIDBIT_SETP (RID_SIGNED, specbits)
10354       || RIDBIT_SETP (RID_LONG, specbits)
10355       || RIDBIT_SETP (RID_SHORT, specbits))
10356     {
10357       int ok = 0;
10358
10359       if (TREE_CODE (type) == REAL_TYPE)
10360         error ("short, signed or unsigned invalid for `%s'", name);
10361       else if (TREE_CODE (type) != INTEGER_TYPE)
10362         error ("long, short, signed or unsigned invalid for `%s'", name);
10363       else if (RIDBIT_SETP (RID_LONG, specbits)
10364                && RIDBIT_SETP (RID_SHORT, specbits))
10365         error ("long and short specified together for `%s'", name);
10366       else if ((RIDBIT_SETP (RID_LONG, specbits)
10367                 || RIDBIT_SETP (RID_SHORT, specbits))
10368                && explicit_char)
10369         error ("long or short specified with char for `%s'", name);
10370       else if ((RIDBIT_SETP (RID_LONG, specbits)
10371                 || RIDBIT_SETP (RID_SHORT, specbits))
10372                && TREE_CODE (type) == REAL_TYPE)
10373         error ("long or short specified with floating type for `%s'", name);
10374       else if (RIDBIT_SETP (RID_SIGNED, specbits)
10375                && RIDBIT_SETP (RID_UNSIGNED, specbits))
10376         error ("signed and unsigned given together for `%s'", name);
10377       else
10378         {
10379           ok = 1;
10380           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
10381             {
10382               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10383                        name);
10384               if (flag_pedantic_errors)
10385                 ok = 0;
10386             }
10387         }
10388
10389       /* Discard the type modifiers if they are invalid.  */
10390       if (! ok)
10391         {
10392           RIDBIT_RESET (RID_UNSIGNED, specbits);
10393           RIDBIT_RESET (RID_SIGNED, specbits);
10394           RIDBIT_RESET (RID_LONG, specbits);
10395           RIDBIT_RESET (RID_SHORT, specbits);
10396           longlong = 0;
10397         }
10398     }
10399
10400   if (RIDBIT_SETP (RID_COMPLEX, specbits)
10401       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
10402     {
10403       error ("complex invalid for `%s'", name);
10404       RIDBIT_RESET (RID_COMPLEX, specbits);
10405     }
10406
10407   /* Decide whether an integer type is signed or not.
10408      Optionally treat bitfields as signed by default.  */
10409   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10410       /* [class.bit]
10411
10412          It is implementation-defined whether a plain (neither
10413          explicitly signed or unsigned) char, short, int, or long
10414          bit-field is signed or unsigned.
10415
10416          Naturally, we extend this to long long as well.  Note that
10417          this does not include wchar_t.  */
10418       || (bitfield && !flag_signed_bitfields
10419           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
10420           /* A typedef for plain `int' without `signed' can be
10421              controlled just like plain `int', but a typedef for
10422              `signed int' cannot be so controlled.  */
10423           && !(typedef_decl
10424                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
10425           && (TREE_CODE (type) == INTEGER_TYPE
10426               || TREE_CODE (type) == CHAR_TYPE)
10427           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
10428     {
10429       if (longlong)
10430         type = long_long_unsigned_type_node;
10431       else if (RIDBIT_SETP (RID_LONG, specbits))
10432         type = long_unsigned_type_node;
10433       else if (RIDBIT_SETP (RID_SHORT, specbits))
10434         type = short_unsigned_type_node;
10435       else if (type == char_type_node)
10436         type = unsigned_char_type_node;
10437       else if (typedef_decl)
10438         type = unsigned_type (type);
10439       else
10440         type = unsigned_type_node;
10441     }
10442   else if (RIDBIT_SETP (RID_SIGNED, specbits)
10443            && type == char_type_node)
10444     type = signed_char_type_node;
10445   else if (longlong)
10446     type = long_long_integer_type_node;
10447   else if (RIDBIT_SETP (RID_LONG, specbits))
10448     type = long_integer_type_node;
10449   else if (RIDBIT_SETP (RID_SHORT, specbits))
10450     type = short_integer_type_node;
10451
10452   if (RIDBIT_SETP (RID_COMPLEX, specbits))
10453     {
10454       /* If we just have "complex", it is equivalent to
10455          "complex double", but if any modifiers at all are specified it is
10456          the complex form of TYPE.  E.g, "complex short" is
10457          "complex short int".  */
10458
10459       if (defaulted_int && ! longlong
10460           && ! (RIDBIT_SETP (RID_LONG, specbits)
10461                 || RIDBIT_SETP (RID_SHORT, specbits)
10462                 || RIDBIT_SETP (RID_SIGNED, specbits)
10463                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
10464         type = complex_double_type_node;
10465       else if (type == integer_type_node)
10466         type = complex_integer_type_node;
10467       else if (type == float_type_node)
10468         type = complex_float_type_node;
10469       else if (type == double_type_node)
10470         type = complex_double_type_node;
10471       else if (type == long_double_type_node)
10472         type = complex_long_double_type_node;
10473       else
10474         type = build_complex_type (type);
10475     }
10476
10477   if (sfk == sfk_conversion
10478       && (RIDBIT_SETP (RID_CONST, specbits)
10479           || RIDBIT_SETP (RID_VOLATILE, specbits)
10480           || RIDBIT_SETP (RID_RESTRICT, specbits)))
10481     cp_error ("qualifiers are not allowed on declaration of `operator %T'",
10482               ctor_return_type);
10483
10484   /* Set CONSTP if this declaration is `const', whether by
10485      explicit specification or via a typedef.
10486      Likewise for VOLATILEP.  */
10487
10488   constp = !! RIDBIT_SETP (RID_CONST, specbits) + CP_TYPE_CONST_P (type);
10489   restrictp =
10490     !! RIDBIT_SETP (RID_RESTRICT, specbits) + CP_TYPE_RESTRICT_P (type);
10491   volatilep =
10492     !! RIDBIT_SETP (RID_VOLATILE, specbits) + CP_TYPE_VOLATILE_P (type);
10493   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10494                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10495                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10496   type = cp_build_qualified_type (type, type_quals);
10497   staticp = 0;
10498   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
10499   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
10500   RIDBIT_RESET (RID_VIRTUAL, specbits);
10501   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
10502   RIDBIT_RESET (RID_EXPLICIT, specbits);
10503
10504   if (RIDBIT_SETP (RID_STATIC, specbits))
10505     staticp = 1 + (decl_context == FIELD);
10506
10507   if (virtualp && staticp == 2)
10508     {
10509       cp_error ("member `%D' cannot be declared both virtual and static",
10510                 dname);
10511       staticp = 0;
10512     }
10513   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
10514   RIDBIT_RESET (RID_FRIEND, specbits);
10515
10516   /* Warn if two storage classes are given. Default to `auto'.  */
10517
10518   if (RIDBIT_ANY_SET (specbits))
10519     {
10520       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
10521       if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
10522       if (decl_context == PARM && nclasses > 0)
10523         error ("storage class specifiers invalid in parameter declarations");
10524       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10525         {
10526           if (decl_context == PARM)
10527             error ("typedef declaration invalid in parameter declaration");
10528           nclasses++;
10529         }
10530       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
10531       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
10532     }
10533
10534   /* Give error if `virtual' is used outside of class declaration.  */
10535   if (virtualp
10536       && (current_class_name == NULL_TREE || decl_context != FIELD))
10537     {
10538       error ("virtual outside class declaration");
10539       virtualp = 0;
10540     }
10541
10542   /* Static anonymous unions are dealt with here.  */
10543   if (staticp && decl_context == TYPENAME
10544       && TREE_CODE (declspecs) == TREE_LIST
10545       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
10546     decl_context = FIELD;
10547
10548   /* Warn about storage classes that are invalid for certain
10549      kinds of declarations (parameters, typenames, etc.).  */
10550
10551   if (nclasses > 1)
10552     error ("multiple storage classes in declaration of `%s'", name);
10553   else if (decl_context != NORMAL && nclasses > 0)
10554     {
10555       if ((decl_context == PARM || decl_context == CATCHPARM)
10556           && (RIDBIT_SETP (RID_REGISTER, specbits)
10557               || RIDBIT_SETP (RID_AUTO, specbits)))
10558         ;
10559       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10560         ;
10561       else if (decl_context == FIELD
10562                /* C++ allows static class elements  */
10563                && RIDBIT_SETP (RID_STATIC, specbits))
10564         /* C++ also allows inlines and signed and unsigned elements,
10565            but in those cases we don't come in here.  */
10566         ;
10567       else
10568         {
10569           if (decl_context == FIELD)
10570             {
10571               tree tmp = NULL_TREE;
10572               register int op = 0;
10573
10574               if (declarator)
10575                 {
10576                   /* Avoid trying to get an operand off an identifier node.  */
10577                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10578                     tmp = declarator;
10579                   else
10580                     tmp = TREE_OPERAND (declarator, 0);
10581                   op = IDENTIFIER_OPNAME_P (tmp);
10582                   if (IDENTIFIER_TYPENAME_P (tmp))
10583                     {
10584                       if (IDENTIFIER_GLOBAL_VALUE (tmp)
10585                           && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (tmp))
10586                               == TYPE_DECL))
10587                         name = IDENTIFIER_POINTER (tmp);
10588                       else
10589                         name = "<invalid operator>";
10590                     }
10591                 }
10592               error ("storage class specified for %s `%s'",
10593                      op ? "member operator" : "field",
10594                      name);
10595             }
10596           else
10597             {
10598               if (decl_context == PARM || decl_context == CATCHPARM)
10599                 error ("storage class specified for parameter `%s'", name);
10600               else
10601                 error ("storage class specified for typename");
10602             }
10603           RIDBIT_RESET (RID_REGISTER, specbits);
10604           RIDBIT_RESET (RID_AUTO, specbits);
10605           RIDBIT_RESET (RID_EXTERN, specbits);
10606         }
10607     }
10608   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10609     {
10610       if (toplevel_bindings_p ())
10611         {
10612           /* It's common practice (and completely valid) to have a const
10613              be initialized and declared extern.  */
10614           if (!(type_quals & TYPE_QUAL_CONST))
10615             warning ("`%s' initialized and declared `extern'", name);
10616         }
10617       else
10618         error ("`%s' has both `extern' and initializer", name);
10619     }
10620   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10621            && ! toplevel_bindings_p ())
10622     error ("nested function `%s' declared `extern'", name);
10623   else if (toplevel_bindings_p ())
10624     {
10625       if (RIDBIT_SETP (RID_AUTO, specbits))
10626         error ("top-level declaration of `%s' specifies `auto'", name);
10627     }
10628
10629   if (nclasses > 0 && friendp)
10630     error ("storage class specifiers invalid in friend function declarations");
10631
10632   /* Now figure out the structure of the declarator proper.
10633      Descend through it, creating more complex types, until we reach
10634      the declared identifier (or NULL_TREE, in an absolute declarator).  */
10635
10636   inner_attrs = NULL_TREE;
10637   ignore_attrs = 0;
10638
10639   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10640          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10641     {
10642       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10643          an INDIRECT_REF (for *...),
10644          a CALL_EXPR (for ...(...)),
10645          an identifier (for the name being declared)
10646          or a null pointer (for the place in an absolute declarator
10647          where the name was omitted).
10648          For the last two cases, we have just exited the loop.
10649
10650          For C++ it could also be
10651          a SCOPE_REF (for class :: ...).  In this case, we have converted
10652          sensible names to types, and those are the values we use to
10653          qualify the member name.
10654          an ADDR_EXPR (for &...),
10655          a BIT_NOT_EXPR (for destructors)
10656
10657          At this point, TYPE is the type of elements of an array,
10658          or for a function to return, or for a pointer to point to.
10659          After this sequence of ifs, TYPE is the type of the
10660          array or function or pointer, and DECLARATOR has had its
10661          outermost layer removed.  */
10662
10663       if (type == error_mark_node)
10664         {
10665           if (TREE_CODE (declarator) == SCOPE_REF)
10666             declarator = TREE_OPERAND (declarator, 1);
10667           else
10668             declarator = TREE_OPERAND (declarator, 0);
10669           continue;
10670         }
10671       if (quals != NULL_TREE
10672           && (declarator == NULL_TREE
10673               || TREE_CODE (declarator) != SCOPE_REF))
10674         {
10675           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10676             ctype = TYPE_METHOD_BASETYPE (type);
10677           if (ctype != NULL_TREE)
10678             {
10679               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10680               grok_method_quals (ctype, dummy, quals);
10681               type = TREE_TYPE (dummy);
10682               ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
10683               quals = NULL_TREE;
10684             }
10685         }
10686
10687       /* See the comment for the TREE_LIST case, below.  */
10688       if (ignore_attrs)
10689         ignore_attrs = 0;
10690       else if (inner_attrs)
10691         {
10692           decl_attributes (type, inner_attrs, NULL_TREE);
10693           inner_attrs = NULL_TREE;
10694         }
10695
10696       switch (TREE_CODE (declarator))
10697         {
10698         case TREE_LIST:
10699           {
10700             /* We encode a declarator with embedded attributes using
10701                a TREE_LIST.  The attributes apply to the declarator
10702                directly inside them, so we have to skip an iteration
10703                before applying them to the type.  If the declarator just
10704                inside is the declarator-id, we apply the attrs to the
10705                decl itself.  */
10706             inner_attrs = TREE_PURPOSE (declarator);
10707             ignore_attrs = 1;
10708             declarator = TREE_VALUE (declarator);
10709           }
10710           break;
10711
10712         case ARRAY_REF:
10713           {
10714             register tree size;
10715
10716             size = TREE_OPERAND (declarator, 1);
10717
10718             /* VC++ spells a zero-sized array with [].  */
10719             if (size == NULL_TREE && decl_context == FIELD && ! staticp
10720                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10721               size = integer_zero_node;
10722
10723             declarator = TREE_OPERAND (declarator, 0);
10724
10725             type = create_array_type_for_decl (dname, type, size);
10726
10727             /* VLAs never work as fields. */
10728             if (decl_context == FIELD && !processing_template_decl
10729                 && TREE_CODE (type) == ARRAY_TYPE
10730                 && TYPE_DOMAIN (type) != NULL_TREE
10731                 && !TREE_CONSTANT (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
10732               {
10733                 cp_error ("size of member `%D' is not constant", dname);
10734                 /* Proceed with arbitrary constant size, so that offset
10735                    computations don't get confused. */
10736                 type = create_array_type_for_decl (dname, TREE_TYPE (type),
10737                                                    integer_one_node);
10738               }
10739
10740             ctype = NULL_TREE;
10741           }
10742           break;
10743
10744         case CALL_EXPR:
10745           {
10746             tree arg_types;
10747             int funcdecl_p;
10748             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10749             tree inner_decl = TREE_OPERAND (declarator, 0);
10750
10751             /* Declaring a function type.
10752                Make sure we have a valid type for the function to return.  */
10753
10754             /* We now know that the TYPE_QUALS don't apply to the
10755                decl, but to its return type.  */
10756             type_quals = TYPE_UNQUALIFIED;
10757
10758             /* Warn about some types functions can't return.  */
10759
10760             if (TREE_CODE (type) == FUNCTION_TYPE)
10761               {
10762                 error ("`%s' declared as function returning a function", name);
10763                 type = integer_type_node;
10764               }
10765             if (TREE_CODE (type) == ARRAY_TYPE)
10766               {
10767                 error ("`%s' declared as function returning an array", name);
10768                 type = integer_type_node;
10769               }
10770
10771             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10772               inner_decl = TREE_OPERAND (inner_decl, 1);
10773
10774             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10775               inner_decl = dname;
10776
10777             /* Pick up type qualifiers which should be applied to `this'.  */
10778             quals = CALL_DECLARATOR_QUALS (declarator);
10779
10780             /* Pick up the exception specifications.  */
10781             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10782
10783             /* Say it's a definition only for the CALL_EXPR
10784                closest to the identifier.  */
10785             funcdecl_p
10786               = inner_decl
10787               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10788                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10789                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10790
10791             if (ctype == NULL_TREE
10792                 && decl_context == FIELD
10793                 && funcdecl_p
10794                 && (friendp == 0 || dname == current_class_name))
10795               ctype = current_class_type;
10796
10797             if (ctype && sfk == sfk_conversion)
10798               TYPE_HAS_CONVERSION (ctype) = 1;
10799             if (ctype && constructor_name (ctype) == dname)
10800               {
10801                 /* We are within a class's scope. If our declarator name
10802                    is the same as the class name, and we are defining
10803                    a function, then it is a constructor/destructor, and
10804                    therefore returns a void type.  */
10805
10806                 if (flags == DTOR_FLAG)
10807                   {
10808                     /* ISO C++ 12.4/2.  A destructor may not be
10809                        declared const or volatile.  A destructor may
10810                        not be static.  */
10811                     if (staticp == 2)
10812                       error ("destructor cannot be static member function");
10813                     if (quals)
10814                       {
10815                         cp_error ("destructors may not be `%s'",
10816                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10817                         quals = NULL_TREE;
10818                       }
10819                     if (decl_context == FIELD)
10820                       {
10821                         if (! member_function_or_else (ctype,
10822                                                        current_class_type,
10823                                                        flags))
10824                           return void_type_node;
10825                       }
10826                   }
10827                 else            /* It's a constructor.  */
10828                   {
10829                     if (explicitp == 1)
10830                       explicitp = 2;
10831                     /* ISO C++ 12.1.  A constructor may not be
10832                        declared const or volatile.  A constructor may
10833                        not be virtual.  A constructor may not be
10834                        static.  */
10835                     if (staticp == 2)
10836                       error ("constructor cannot be static member function");
10837                     if (virtualp)
10838                       {
10839                         pedwarn ("constructors cannot be declared virtual");
10840                         virtualp = 0;
10841                       }
10842                     if (quals)
10843                       {
10844                         cp_error ("constructors may not be `%s'",
10845                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10846                         quals = NULL_TREE;
10847                       }
10848                     {
10849                       RID_BIT_TYPE tmp_bits;
10850                       bcopy ((void*)&specbits, (void*)&tmp_bits, sizeof (RID_BIT_TYPE));
10851                       RIDBIT_RESET (RID_INLINE, tmp_bits);
10852                       RIDBIT_RESET (RID_STATIC, tmp_bits);
10853                       if (RIDBIT_ANY_SET (tmp_bits))
10854                         error ("return value type specifier for constructor ignored");
10855                     }
10856                     if (decl_context == FIELD)
10857                       {
10858                         if (! member_function_or_else (ctype,
10859                                                        current_class_type,
10860                                                        flags))
10861                           return void_type_node;
10862                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10863                         if (sfk != sfk_constructor)
10864                           return NULL_TREE;
10865                       }
10866                   }
10867                 if (decl_context == FIELD)
10868                   staticp = 0;
10869               }
10870             else if (friendp)
10871               {
10872                 if (initialized)
10873                   error ("can't initialize friend function `%s'", name);
10874                 if (virtualp)
10875                   {
10876                     /* Cannot be both friend and virtual.  */
10877                     error ("virtual functions cannot be friends");
10878                     RIDBIT_RESET (RID_FRIEND, specbits);
10879                     friendp = 0;
10880                   }
10881                 if (decl_context == NORMAL)
10882                   error ("friend declaration not in class definition");
10883                 if (current_function_decl && funcdef_flag)
10884                   cp_error ("can't define friend function `%s' in a local class definition",
10885                             name);
10886               }
10887
10888             /* Construct the function type and go to the next
10889                inner layer of declarator.  */
10890
10891             declarator = TREE_OPERAND (declarator, 0);
10892
10893             /* FIXME: This is where default args should be fully
10894                processed.  */
10895
10896             arg_types = grokparms (inner_parms, funcdecl_p ? funcdef_flag : 0);
10897
10898             if (declarator && flags == DTOR_FLAG)
10899               {
10900                 /* A destructor declared in the body of a class will
10901                    be represented as a BIT_NOT_EXPR.  But, we just
10902                    want the underlying IDENTIFIER.  */
10903                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10904                   declarator = TREE_OPERAND (declarator, 0);
10905
10906                 if (arg_types != void_list_node)
10907                   {
10908                     cp_error ("destructors may not have parameters");
10909                     arg_types = void_list_node;
10910                     last_function_parms = NULL_TREE;
10911                   }
10912               }
10913
10914             /* ANSI says that `const int foo ();'
10915                does not make the function foo const.  */
10916             type = build_function_type (type, arg_types);
10917
10918             {
10919               tree t;
10920               for (t = arg_types; t; t = TREE_CHAIN (t))
10921                 if (TREE_PURPOSE (t)
10922                     && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10923                   {
10924                     add_defarg_fn (type);
10925                     break;
10926                   }
10927             }
10928           }
10929           break;
10930
10931         case ADDR_EXPR:
10932         case INDIRECT_REF:
10933           /* Filter out pointers-to-references and references-to-references.
10934              We can get these if a TYPE_DECL is used.  */
10935
10936           if (TREE_CODE (type) == REFERENCE_TYPE)
10937             {
10938               error ("cannot declare %s to references",
10939                      TREE_CODE (declarator) == ADDR_EXPR
10940                      ? "references" : "pointers");
10941               declarator = TREE_OPERAND (declarator, 0);
10942               continue;
10943             }
10944
10945           if (TREE_CODE (type) == OFFSET_TYPE
10946               && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10947                   || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10948             {
10949               cp_error ("cannot declare pointer to `%#T' member",
10950                         TREE_TYPE (type));
10951               type = TREE_TYPE (type);
10952             }
10953
10954           /* Merge any constancy or volatility into the target type
10955              for the pointer.  */
10956
10957           /* We now know that the TYPE_QUALS don't apply to the decl,
10958              but to the target of the pointer.  */
10959           type_quals = TYPE_UNQUALIFIED;
10960
10961           if (TREE_CODE (declarator) == ADDR_EXPR)
10962             {
10963               if (TREE_CODE (type) == VOID_TYPE)
10964                 error ("invalid type: `void &'");
10965               else
10966                 type = build_reference_type (type);
10967             }
10968           else if (TREE_CODE (type) == METHOD_TYPE)
10969             type = build_ptrmemfunc_type (build_pointer_type (type));
10970           else
10971             type = build_pointer_type (type);
10972
10973           /* Process a list of type modifier keywords (such as
10974              const or volatile) that were given inside the `*' or `&'.  */
10975
10976           if (TREE_TYPE (declarator))
10977             {
10978               register tree typemodlist;
10979               int erred = 0;
10980
10981               constp = 0;
10982               volatilep = 0;
10983               restrictp = 0;
10984               for (typemodlist = TREE_TYPE (declarator); typemodlist;
10985                    typemodlist = TREE_CHAIN (typemodlist))
10986                 {
10987                   tree qualifier = TREE_VALUE (typemodlist);
10988
10989                   if (qualifier == ridpointers[(int) RID_CONST])
10990                     constp++;
10991                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
10992                     volatilep++;
10993                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
10994                     restrictp++;
10995                   else if (!erred)
10996                     {
10997                       erred = 1;
10998                       error ("invalid type modifier within pointer declarator");
10999                     }
11000                 }
11001               if (constp > 1)
11002                 pedwarn ("duplicate `const'");
11003               if (volatilep > 1)
11004                 pedwarn ("duplicate `volatile'");
11005               if (restrictp > 1)
11006                 pedwarn ("duplicate `restrict'");
11007
11008               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
11009                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
11010                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
11011               if (TREE_CODE (declarator) == ADDR_EXPR
11012                   && (constp || volatilep))
11013                 {
11014                   if (constp)
11015                     pedwarn ("discarding `const' applied to a reference");
11016                   if (volatilep)
11017                     pedwarn ("discarding `volatile' applied to a reference");
11018                   type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
11019                 }
11020               type = cp_build_qualified_type (type, type_quals);
11021             }
11022           declarator = TREE_OPERAND (declarator, 0);
11023           ctype = NULL_TREE;
11024           break;
11025
11026         case SCOPE_REF:
11027           {
11028             /* We have converted type names to NULL_TREE if the
11029                name was bogus, or to a _TYPE node, if not.
11030
11031                The variable CTYPE holds the type we will ultimately
11032                resolve to.  The code here just needs to build
11033                up appropriate member types.  */
11034             tree sname = TREE_OPERAND (declarator, 1);
11035             tree t;
11036
11037             /* Destructors can have their visibilities changed as well.  */
11038             if (TREE_CODE (sname) == BIT_NOT_EXPR)
11039               sname = TREE_OPERAND (sname, 0);
11040
11041             if (TREE_COMPLEXITY (declarator) == 0)
11042               /* This needs to be here, in case we are called
11043                  multiple times.  */ ;
11044             else if (TREE_COMPLEXITY (declarator) == -1)
11045               /* Namespace member. */
11046               pop_decl_namespace ();
11047             else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
11048               /* Don't fall out into global scope. Hides real bug? --eichin */ ;
11049             else if (! IS_AGGR_TYPE_CODE
11050                      (TREE_CODE (TREE_OPERAND (declarator, 0))))
11051               ;
11052             else if (TREE_COMPLEXITY (declarator) == current_class_depth)
11053               {
11054                 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
11055                    that refer to ctype.  They couldn't be resolved earlier
11056                    because we hadn't pushed into the class yet.
11057                    Example: resolve 'B<T>::type' in
11058                    'B<typename B<T>::type> B<T>::f () { }'.  */
11059                 if (current_template_parms
11060                     && uses_template_parms (type)
11061                     && uses_template_parms (current_class_type))
11062                   {
11063                     tree args = current_template_args ();
11064                     type = tsubst (type, args, /*complain=*/1, NULL_TREE);
11065                   }
11066
11067                 /* This pop_nested_class corresponds to the
11068                    push_nested_class used to push into class scope for
11069                    parsing the argument list of a function decl, in
11070                    qualified_id.  */
11071                 pop_nested_class ();
11072                 TREE_COMPLEXITY (declarator) = current_class_depth;
11073               }
11074             else
11075               my_friendly_abort (16);
11076
11077             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
11078               {
11079                 /* We had a reference to a global decl, or
11080                    perhaps we were given a non-aggregate typedef,
11081                    in which case we cleared this out, and should just
11082                    keep going as though it wasn't there.  */
11083                 declarator = sname;
11084                 continue;
11085               }
11086             ctype = TREE_OPERAND (declarator, 0);
11087
11088             t = ctype;
11089             while (t != NULL_TREE && CLASS_TYPE_P (t))
11090               {
11091                 /* You're supposed to have one `template <...>'
11092                    for every template class, but you don't need one
11093                    for a full specialization.  For example:
11094
11095                      template <class T> struct S{};
11096                      template <> struct S<int> { void f(); };
11097                      void S<int>::f () {}
11098
11099                    is correct; there shouldn't be a `template <>' for
11100                    the definition of `S<int>::f'.  */
11101                 if (CLASSTYPE_TEMPLATE_INFO (t)
11102                     && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
11103                         || uses_template_parms (CLASSTYPE_TI_ARGS (t))))
11104                   template_count += 1;
11105
11106                 t = TYPE_MAIN_DECL (t);
11107                 if (DECL_LANG_SPECIFIC (t))
11108                   t = DECL_CONTEXT (t);
11109                 else
11110                   t = NULL_TREE;
11111               }
11112
11113             if (sname == NULL_TREE)
11114               goto done_scoping;
11115
11116             if (TREE_CODE (sname) == IDENTIFIER_NODE)
11117               {
11118                 /* This is the `standard' use of the scoping operator:
11119                    basetype :: member .  */
11120
11121                 if (ctype == current_class_type)
11122                   {
11123                     /* class A {
11124                          void A::f ();
11125                        };
11126
11127                        Is this ill-formed?  */
11128
11129                     if (pedantic)
11130                       cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
11131                                   ctype, name);
11132                   }
11133                 else if (TREE_CODE (type) == FUNCTION_TYPE)
11134                   {
11135                     if (current_class_type == NULL_TREE
11136                         || friendp)
11137                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
11138                                                       TYPE_ARG_TYPES (type));
11139                     else
11140                       {
11141                         cp_error ("cannot declare member function `%T::%s' within `%T'",
11142                                   ctype, name, current_class_type);
11143                         return void_type_node;
11144                       }
11145                   }
11146                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
11147                          || COMPLETE_TYPE_P (complete_type (ctype)))
11148                   {
11149                     /* Have to move this code elsewhere in this function.
11150                        this code is used for i.e., typedef int A::M; M *pm;
11151
11152                        It is?  How? jason 10/2/94 */
11153
11154                     if (current_class_type)
11155                       {
11156                         cp_error ("cannot declare member `%T::%s' within `%T'",
11157                                   ctype, name, current_class_type);
11158                         return void_type_node;
11159                       }
11160                     type = build_offset_type (ctype, type);
11161                   }
11162                 else if (uses_template_parms (ctype))
11163                   {
11164                     if (TREE_CODE (type) == FUNCTION_TYPE)
11165                       type
11166                         = build_cplus_method_type (ctype, TREE_TYPE (type),
11167                                                    TYPE_ARG_TYPES (type));
11168                   }
11169                 else
11170                   {
11171                     cp_error ("structure `%T' not yet defined", ctype);
11172                     return error_mark_node;
11173                   }
11174
11175                 declarator = sname;
11176               }
11177             else if (TREE_CODE (sname) == SCOPE_REF)
11178               my_friendly_abort (17);
11179             else
11180               {
11181               done_scoping:
11182                 declarator = TREE_OPERAND (declarator, 1);
11183                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
11184                   /* In this case, we will deal with it later.  */
11185                   ;
11186                 else
11187                   {
11188                     if (TREE_CODE (type) == FUNCTION_TYPE)
11189                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
11190                                                       TYPE_ARG_TYPES (type));
11191                     else
11192                       type = build_offset_type (ctype, type);
11193                   }
11194               }
11195           }
11196           break;
11197
11198         case BIT_NOT_EXPR:
11199           declarator = TREE_OPERAND (declarator, 0);
11200           break;
11201
11202         case RECORD_TYPE:
11203         case UNION_TYPE:
11204         case ENUMERAL_TYPE:
11205           declarator = NULL_TREE;
11206           break;
11207
11208         case ERROR_MARK:
11209           declarator = NULL_TREE;
11210           break;
11211
11212         default:
11213           my_friendly_abort (158);
11214         }
11215     }
11216
11217   /* See the comment for the TREE_LIST case, above.  */
11218   if (inner_attrs)
11219     {
11220       if (! ignore_attrs)
11221         decl_attributes (type, inner_attrs, NULL_TREE);
11222       else if (attrlist)
11223         TREE_VALUE (attrlist) = chainon (inner_attrs, TREE_VALUE (attrlist));
11224       else
11225         attrlist = build_decl_list (NULL_TREE, inner_attrs);
11226     }
11227
11228   /* Now TYPE has the actual type.  */
11229
11230   if (explicitp == 1 || (explicitp && friendp))
11231     {
11232       /* [dcl.fct.spec] The explicit specifier shall only be used in
11233          declarations of constructors within a class definition.  */
11234       error ("only declarations of constructors can be `explicit'");
11235       explicitp = 0;
11236     }
11237
11238   if (RIDBIT_SETP (RID_MUTABLE, specbits))
11239     {
11240       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
11241         {
11242           error ("non-member `%s' cannot be declared `mutable'", name);
11243           RIDBIT_RESET (RID_MUTABLE, specbits);
11244         }
11245       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
11246         {
11247           error ("non-object member `%s' cannot be declared `mutable'", name);
11248           RIDBIT_RESET (RID_MUTABLE, specbits);
11249         }
11250       else if (TREE_CODE (type) == FUNCTION_TYPE
11251                || TREE_CODE (type) == METHOD_TYPE)
11252         {
11253           error ("function `%s' cannot be declared `mutable'", name);
11254           RIDBIT_RESET (RID_MUTABLE, specbits);
11255         }
11256       else if (staticp)
11257         {
11258           error ("static `%s' cannot be declared `mutable'", name);
11259           RIDBIT_RESET (RID_MUTABLE, specbits);
11260         }
11261       else if (type_quals & TYPE_QUAL_CONST)
11262         {
11263           error ("const `%s' cannot be declared `mutable'", name);
11264           RIDBIT_RESET (RID_MUTABLE, specbits);
11265         }
11266     }
11267
11268   if (declarator == NULL_TREE
11269       || TREE_CODE (declarator) == IDENTIFIER_NODE
11270       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
11271           && (TREE_CODE (type) == FUNCTION_TYPE
11272               || TREE_CODE (type) == METHOD_TYPE)))
11273     /* OK */;
11274   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11275     {
11276       cp_error ("template-id `%D' used as a declarator", declarator);
11277       declarator = dname;
11278     }
11279   else
11280     /* Unexpected declarator format.  */
11281     my_friendly_abort (990210);
11282
11283   /* If this is declaring a typedef name, return a TYPE_DECL.  */
11284
11285   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
11286     {
11287       tree decl;
11288
11289       /* Note that the grammar rejects storage classes
11290          in typenames, fields or parameters.  */
11291       if (current_lang_name == lang_name_java)
11292         TYPE_FOR_JAVA (type) = 1;
11293
11294       if (decl_context == FIELD)
11295         {
11296           if (declarator == constructor_name (current_class_type))
11297             cp_pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
11298                         declarator);
11299           decl = build_lang_decl (TYPE_DECL, declarator, type);
11300         }
11301       else
11302         decl = build_decl (TYPE_DECL, declarator, type);
11303
11304       /* If the user declares "typedef struct {...} foo" then the
11305          struct will have an anonymous name.  Fill that name in now.
11306          Nothing can refer to it, so nothing needs know about the name
11307          change.  */
11308       if (type != error_mark_node
11309           && declarator
11310           && TYPE_NAME (type)
11311           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11312           && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type))
11313           && CP_TYPE_QUALS (type) == TYPE_UNQUALIFIED)
11314         {
11315           tree oldname = TYPE_NAME (type);
11316           tree t;
11317
11318           /* Replace the anonymous name with the real name everywhere.  */
11319           lookup_tag_reverse (type, declarator);
11320           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
11321             if (TYPE_NAME (t) == oldname)
11322               TYPE_NAME (t) = decl;
11323
11324           if (TYPE_LANG_SPECIFIC (type))
11325             TYPE_WAS_ANONYMOUS (type) = 1;
11326
11327           /* If this is a typedef within a template class, the nested
11328              type is a (non-primary) template.  The name for the
11329              template needs updating as well.  */
11330           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
11331             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
11332               = TYPE_IDENTIFIER (type);
11333
11334           if (flag_new_abi)
11335             DECL_ASSEMBLER_NAME (decl) = mangle_type (type);
11336           else
11337             {
11338               /* XXX Temporarily set the scope.
11339                  When returning, start_decl expects it as NULL_TREE,
11340                  and will then then set it using pushdecl. */
11341               my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 980404);
11342               if (current_class_type)
11343                 DECL_CONTEXT (decl) = current_class_type;
11344               else
11345                 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
11346
11347               DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
11348               DECL_ASSEMBLER_NAME (decl)
11349                 = get_identifier (build_overload_name (type, 1, 1));
11350               DECL_CONTEXT (decl) = NULL_TREE;
11351             }
11352
11353           /* FIXME remangle member functions; member functions of a
11354              type with external linkage have external linkage.  */
11355         }
11356
11357       if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
11358         {
11359           cp_error_at ("typedef name may not be class-qualified", decl);
11360           return NULL_TREE;
11361         }
11362       else if (quals)
11363         {
11364           if (ctype == NULL_TREE)
11365             {
11366               if (TREE_CODE (type) != METHOD_TYPE)
11367                 cp_error_at ("invalid type qualifier for non-member function type", decl);
11368               else
11369                 ctype = TYPE_METHOD_BASETYPE (type);
11370             }
11371           if (ctype != NULL_TREE)
11372             grok_method_quals (ctype, decl, quals);
11373         }
11374
11375       if (RIDBIT_SETP (RID_SIGNED, specbits)
11376           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
11377         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
11378
11379       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
11380                       inlinep, friendp, raises != NULL_TREE);
11381
11382       if (initialized)
11383         error ("typedef declaration includes an initializer");
11384
11385       return decl;
11386     }
11387
11388   /* Detect the case of an array type of unspecified size
11389      which came, as such, direct from a typedef name.
11390      We must copy the type, so that each identifier gets
11391      a distinct type, so that each identifier's size can be
11392      controlled separately by its own initializer.  */
11393
11394   if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
11395       && TYPE_DOMAIN (type) == NULL_TREE)
11396     {
11397       type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
11398     }
11399
11400   /* If this is a type name (such as, in a cast or sizeof),
11401      compute the type and return it now.  */
11402
11403   if (decl_context == TYPENAME)
11404     {
11405       /* Note that the grammar rejects storage classes
11406          in typenames, fields or parameters.  */
11407       if (type_quals != TYPE_UNQUALIFIED)
11408         type_quals = TYPE_UNQUALIFIED;
11409
11410       /* Special case: "friend class foo" looks like a TYPENAME context.  */
11411       if (friendp)
11412         {
11413           if (type_quals != TYPE_UNQUALIFIED)
11414             {
11415               cp_error ("type qualifiers specified for friend class declaration");
11416               type_quals = TYPE_UNQUALIFIED;
11417             }
11418           if (inlinep)
11419             {
11420               cp_error ("`inline' specified for friend class declaration");
11421               inlinep = 0;
11422             }
11423           if (!current_aggr && TREE_CODE (type) != TYPENAME_TYPE)
11424             {
11425               if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
11426                 cp_error ("template parameters cannot be friends");
11427               else
11428                 cp_error ("friend declaration requires `%#T'", type);
11429             }
11430
11431           /* Only try to do this stuff if we didn't already give up.  */
11432           if (type != integer_type_node)
11433             {
11434               /* A friendly class?  */
11435               if (current_class_type)
11436                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
11437               else
11438                 cp_error ("trying to make class `%T' a friend of global scope",
11439                           type);
11440               type = void_type_node;
11441             }
11442         }
11443       else if (quals)
11444         {
11445           if (ctype == NULL_TREE)
11446             {
11447               if (TREE_CODE (type) != METHOD_TYPE)
11448                 cp_error ("invalid qualifiers on non-member function type");
11449               else
11450                 ctype = TYPE_METHOD_BASETYPE (type);
11451             }
11452           if (ctype)
11453             {
11454               tree dummy = build_decl (TYPE_DECL, declarator, type);
11455               grok_method_quals (ctype, dummy, quals);
11456               type = TREE_TYPE (dummy);
11457             }
11458         }
11459
11460       return type;
11461     }
11462   else if (declarator == NULL_TREE && decl_context != PARM
11463            && decl_context != CATCHPARM
11464            && TREE_CODE (type) != UNION_TYPE
11465            && ! bitfield)
11466     {
11467       cp_error ("abstract declarator `%T' used as declaration", type);
11468       declarator = make_anon_name ();
11469     }
11470
11471   /* `void' at top level (not within pointer)
11472      is allowed only in typedefs or type names.
11473      We don't complain about parms either, but that is because
11474      a better error message can be made later.  */
11475
11476   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
11477     {
11478       if (! declarator)
11479         error ("unnamed variable or field declared void");
11480       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
11481         {
11482           if (IDENTIFIER_OPNAME_P (declarator))
11483             my_friendly_abort (356);
11484           else
11485             error ("variable or field `%s' declared void", name);
11486         }
11487       else
11488         error ("variable or field declared void");
11489       type = integer_type_node;
11490     }
11491
11492   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11493      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
11494
11495   if (decl_context == PARM || decl_context == CATCHPARM)
11496     {
11497       if (ctype || in_namespace)
11498         error ("cannot use `::' in parameter declaration");
11499
11500       /* A parameter declared as an array of T is really a pointer to T.
11501          One declared as a function is really a pointer to a function.
11502          One declared as a member is really a pointer to member.  */
11503
11504       if (TREE_CODE (type) == ARRAY_TYPE)
11505         {
11506           /* Transfer const-ness of array into that of type pointed to.  */
11507           type = build_pointer_type (TREE_TYPE (type));
11508           type_quals = TYPE_UNQUALIFIED;
11509         }
11510       else if (TREE_CODE (type) == FUNCTION_TYPE)
11511         type = build_pointer_type (type);
11512       else if (TREE_CODE (type) == OFFSET_TYPE)
11513         type = build_pointer_type (type);
11514       else if (TREE_CODE (type) == VOID_TYPE && declarator)
11515         {
11516           error ("declaration of `%s' as void", name);
11517           return NULL_TREE;
11518         }
11519     }
11520
11521   {
11522     register tree decl;
11523
11524     if (decl_context == PARM)
11525       {
11526         decl = build_decl (PARM_DECL, declarator, type);
11527
11528         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
11529                         inlinep, friendp, raises != NULL_TREE);
11530
11531         /* Compute the type actually passed in the parmlist,
11532            for the case where there is no prototype.
11533            (For example, shorts and chars are passed as ints.)
11534            When there is a prototype, this is overridden later.  */
11535
11536         DECL_ARG_TYPE (decl) = type_promotes_to (type);
11537       }
11538     else if (decl_context == FIELD)
11539       {
11540         if (type == error_mark_node)
11541           {
11542             /* Happens when declaring arrays of sizes which
11543                are error_mark_node, for example.  */
11544             decl = NULL_TREE;
11545           }
11546         else if (in_namespace && !friendp)
11547           {
11548             /* Something like struct S { int N::j; };  */
11549             cp_error ("invalid use of `::'");
11550             decl = NULL_TREE;
11551           }
11552         else if (TREE_CODE (type) == FUNCTION_TYPE)
11553           {
11554             int publicp = 0;
11555             tree function_context;
11556
11557             /* We catch the others as conflicts with the builtin
11558                typedefs.  */
11559             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11560               {
11561                 cp_error ("function `%D' cannot be declared friend",
11562                           declarator);
11563                 friendp = 0;
11564               }
11565
11566             if (friendp == 0)
11567               {
11568                 if (ctype == NULL_TREE)
11569                   ctype = current_class_type;
11570
11571                 if (ctype == NULL_TREE)
11572                   {
11573                     cp_error ("can't make `%D' into a method -- not in a class",
11574                               declarator);
11575                     return void_type_node;
11576                   }
11577
11578                 /* ``A union may [ ... ] not [ have ] virtual functions.''
11579                    ARM 9.5 */
11580                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11581                   {
11582                     cp_error ("function `%D' declared virtual inside a union",
11583                               declarator);
11584                     return void_type_node;
11585                   }
11586
11587                 if (declarator == ansi_opname (NEW_EXPR)
11588                     || declarator == ansi_opname (VEC_NEW_EXPR)
11589                     || declarator == ansi_opname (DELETE_EXPR)
11590                     || declarator == ansi_opname (VEC_DELETE_EXPR))
11591                   {
11592                     if (virtualp)
11593                       {
11594                         cp_error ("`%D' cannot be declared virtual, since it is always static",
11595                                   declarator);
11596                         virtualp = 0;
11597                       }
11598                   }
11599                 else if (staticp < 2)
11600                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11601                                                   TYPE_ARG_TYPES (type));
11602               }
11603
11604             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
11605             function_context = (ctype != NULL_TREE) ?
11606               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11607             publicp = (! friendp || ! staticp)
11608               && function_context == NULL_TREE;
11609             decl = grokfndecl (ctype, type,
11610                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11611                                ? declarator : dname,
11612                                declarator,
11613                                virtualp, flags, quals, raises,
11614                                friendp ? -1 : 0, friendp, publicp, inlinep,
11615                                funcdef_flag, template_count, in_namespace);
11616             if (decl == NULL_TREE)
11617               return decl;
11618 #if 0
11619             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
11620             /* The decl and setting of decl_machine_attr is also turned off.  */
11621             decl = build_decl_attribute_variant (decl, decl_machine_attr);
11622 #endif
11623
11624             /* [class.conv.ctor]
11625
11626                A constructor declared without the function-specifier
11627                explicit that can be called with a single parameter
11628                specifies a conversion from the type of its first
11629                parameter to the type of its class.  Such a constructor
11630                is called a converting constructor.  */
11631             if (explicitp == 2)
11632               DECL_NONCONVERTING_P (decl) = 1;
11633             else if (DECL_CONSTRUCTOR_P (decl))
11634               {
11635                 /* The constructor can be called with exactly one
11636                    parameter if there is at least one parameter, and
11637                    any subsequent parameters have default arguments.
11638                    We don't look at the first parameter, which is
11639                    really just the `this' parameter for the new
11640                    object.  */
11641                 tree arg_types =
11642                   TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)));
11643
11644                 /* Skip the `in_chrg' argument too, if present.  */
11645                 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
11646                   arg_types = TREE_CHAIN (arg_types);
11647
11648                 if (arg_types == void_list_node
11649                     || (arg_types
11650                         && TREE_CHAIN (arg_types)
11651                         && TREE_CHAIN (arg_types) != void_list_node
11652                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11653                   DECL_NONCONVERTING_P (decl) = 1;
11654               }
11655           }
11656         else if (TREE_CODE (type) == METHOD_TYPE)
11657           {
11658             /* We only get here for friend declarations of
11659                members of other classes.  */
11660             /* All method decls are public, so tell grokfndecl to set
11661                TREE_PUBLIC, also.  */
11662             decl = grokfndecl (ctype, type, declarator, declarator,
11663                                virtualp, flags, quals, raises,
11664                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11665                                template_count, in_namespace);
11666             if (decl == NULL_TREE)
11667               return NULL_TREE;
11668           }
11669         else if (!staticp && ! processing_template_decl
11670                  && !COMPLETE_TYPE_P (complete_type (type))
11671                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11672           {
11673             if (declarator)
11674               cp_error ("field `%D' has incomplete type", declarator);
11675             else
11676               cp_error ("name `%T' has incomplete type", type);
11677
11678             /* If we're instantiating a template, tell them which
11679                instantiation made the field's type be incomplete.  */
11680             if (current_class_type
11681                 && TYPE_NAME (current_class_type)
11682                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11683                 && declspecs && TREE_VALUE (declspecs)
11684                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11685               cp_error ("  in instantiation of template `%T'",
11686                         current_class_type);
11687
11688             type = error_mark_node;
11689             decl = NULL_TREE;
11690           }
11691         else
11692           {
11693             if (friendp)
11694               {
11695                 error ("`%s' is neither function nor member function; cannot be declared friend",
11696                        IDENTIFIER_POINTER (declarator));
11697                 friendp = 0;
11698               }
11699             decl = NULL_TREE;
11700           }
11701
11702         if (friendp)
11703           {
11704             /* Friends are treated specially.  */
11705             if (ctype == current_class_type)
11706               warning ("member functions are implicitly friends of their class");
11707             else
11708               {
11709                 tree t = NULL_TREE;
11710                 if (decl && DECL_NAME (decl))
11711                   {
11712                     if (template_class_depth (current_class_type) == 0)
11713                       {
11714                         decl
11715                           = check_explicit_specialization
11716                           (declarator, decl,
11717                            template_count, 2 * (funcdef_flag != 0) + 4);
11718                         if (decl == error_mark_node)
11719                           return error_mark_node;
11720                       }
11721
11722                     t = do_friend (ctype, declarator, decl,
11723                                    last_function_parms, attrlist, flags, quals,
11724                                    funcdef_flag);
11725                   }
11726                 if (t && funcdef_flag)
11727                   return t;
11728
11729                 return void_type_node;
11730               }
11731           }
11732
11733         /* Structure field.  It may not be a function, except for C++ */
11734
11735         if (decl == NULL_TREE)
11736           {
11737             if (initialized)
11738               {
11739                 if (!staticp)
11740                   {
11741                     /* An attempt is being made to initialize a non-static
11742                        member.  But, from [class.mem]:
11743
11744                        4 A member-declarator can contain a
11745                        constant-initializer only if it declares a static
11746                        member (_class.static_) of integral or enumeration
11747                        type, see _class.static.data_.
11748
11749                        This used to be relatively common practice, but
11750                        the rest of the compiler does not correctly
11751                        handle the initialization unless the member is
11752                        static so we make it static below.  */
11753                     cp_pedwarn ("ISO C++ forbids initialization of member `%D'",
11754                                 declarator);
11755                     cp_pedwarn ("making `%D' static", declarator);
11756                     staticp = 1;
11757                   }
11758
11759                 if (uses_template_parms (type))
11760                   /* We'll check at instantiation time.  */
11761                   ;
11762                 else if (check_static_variable_definition (declarator,
11763                                                            type))
11764                   /* If we just return the declaration, crashes
11765                      will sometimes occur.  We therefore return
11766                      void_type_node, as if this was a friend
11767                      declaration, to cause callers to completely
11768                      ignore this declaration.  */
11769                   return void_type_node;
11770               }
11771
11772             /* 9.2p13 [class.mem] */
11773             if (declarator == constructor_name (current_class_type)
11774                 /* The standard does not allow non-static data members
11775                    here either, but we agreed at the 10/99 meeting
11776                    to change that in TC 1 so that they are allowed in
11777                    classes with no user-defined constructors.  */
11778                 && staticp)
11779               cp_pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
11780                           declarator);
11781
11782             if (staticp)
11783               {
11784                 /* C++ allows static class members.  All other work
11785                    for this is done by grokfield.  */
11786                 decl = build_lang_decl (VAR_DECL, declarator, type);
11787                 TREE_STATIC (decl) = 1;
11788                 /* In class context, 'static' means public access.  */
11789                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11790               }
11791             else
11792               {
11793                 decl = build_decl (FIELD_DECL, declarator, type);
11794                 DECL_NONADDRESSABLE_P (decl) = bitfield;
11795                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11796                   {
11797                     DECL_MUTABLE_P (decl) = 1;
11798                     RIDBIT_RESET (RID_MUTABLE, specbits);
11799                   }
11800               }
11801
11802             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11803                             inlinep, friendp, raises != NULL_TREE);
11804           }
11805       }
11806     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11807       {
11808         tree original_name;
11809         int publicp = 0;
11810
11811         if (! declarator)
11812           return NULL_TREE;
11813
11814         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11815           original_name = dname;
11816         else
11817           original_name = declarator;
11818
11819         if (RIDBIT_SETP (RID_AUTO, specbits))
11820           error ("storage class `auto' invalid for function `%s'", name);
11821         else if (RIDBIT_SETP (RID_REGISTER, specbits))
11822           error ("storage class `register' invalid for function `%s'", name);
11823
11824         /* Function declaration not at top level.
11825            Storage classes other than `extern' are not allowed
11826            and `extern' makes no difference.  */
11827         if (! toplevel_bindings_p ()
11828             && (RIDBIT_SETP (RID_STATIC, specbits)
11829                 || RIDBIT_SETP (RID_INLINE, specbits))
11830             && pedantic)
11831           {
11832             if (RIDBIT_SETP (RID_STATIC, specbits))
11833               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11834             else
11835               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11836           }
11837
11838         if (ctype == NULL_TREE)
11839           {
11840             if (virtualp)
11841               {
11842                 error ("virtual non-class function `%s'", name);
11843                 virtualp = 0;
11844               }
11845           }
11846         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11847           type = build_cplus_method_type (ctype, TREE_TYPE (type),
11848                                           TYPE_ARG_TYPES (type));
11849
11850         /* Record presence of `static'.  */
11851         publicp = (ctype != NULL_TREE
11852                    || RIDBIT_SETP (RID_EXTERN, specbits)
11853                    || !RIDBIT_SETP (RID_STATIC, specbits));
11854
11855         decl = grokfndecl (ctype, type, original_name, declarator,
11856                            virtualp, flags, quals, raises,
11857                            1, friendp,
11858                            publicp, inlinep, funcdef_flag,
11859                            template_count, in_namespace);
11860         if (decl == NULL_TREE)
11861           return NULL_TREE;
11862
11863         if (staticp == 1)
11864           {
11865             int illegal_static = 0;
11866
11867             /* Don't allow a static member function in a class, and forbid
11868                declaring main to be static.  */
11869             if (TREE_CODE (type) == METHOD_TYPE)
11870               {
11871                 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11872                 illegal_static = 1;
11873               }
11874             else if (current_function_decl)
11875               {
11876                 /* FIXME need arm citation */
11877                 error ("cannot declare static function inside another function");
11878                 illegal_static = 1;
11879               }
11880
11881             if (illegal_static)
11882               {
11883                 staticp = 0;
11884                 RIDBIT_RESET (RID_STATIC, specbits);
11885               }
11886           }
11887       }
11888     else
11889       {
11890         /* It's a variable.  */
11891
11892         /* An uninitialized decl with `extern' is a reference.  */
11893         decl = grokvardecl (type, declarator, &specbits,
11894                             initialized,
11895                             (type_quals & TYPE_QUAL_CONST) != 0,
11896                             in_namespace);
11897         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11898                         inlinep, friendp, raises != NULL_TREE);
11899
11900         if (ctype)
11901           {
11902             DECL_CONTEXT (decl) = ctype;
11903             if (staticp == 1)
11904               {
11905                 cp_pedwarn ("static member `%D' re-declared as static", decl);
11906                 staticp = 0;
11907                 RIDBIT_RESET (RID_STATIC, specbits);
11908               }
11909             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11910               {
11911                 cp_error ("static member `%D' declared `register'", decl);
11912                 RIDBIT_RESET (RID_REGISTER, specbits);
11913               }
11914             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11915               {
11916                 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11917                             decl);
11918                 RIDBIT_RESET (RID_EXTERN, specbits);
11919               }
11920           }
11921       }
11922
11923     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11924
11925     /* Record `register' declaration for warnings on &
11926        and in case doing stupid register allocation.  */
11927
11928     if (RIDBIT_SETP (RID_REGISTER, specbits))
11929       DECL_REGISTER (decl) = 1;
11930
11931     if (RIDBIT_SETP (RID_EXTERN, specbits))
11932       DECL_THIS_EXTERN (decl) = 1;
11933
11934     if (RIDBIT_SETP (RID_STATIC, specbits))
11935       DECL_THIS_STATIC (decl) = 1;
11936
11937     /* Record constancy and volatility.  There's no need to do this
11938        when processing a template; we'll do this for the instantiated
11939        declaration based on the type of DECL.  */
11940     if (!processing_template_decl)
11941       c_apply_type_quals_to_decl (type_quals, decl);
11942
11943     return decl;
11944   }
11945 }
11946 \f
11947 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11948    An empty exprlist is a parmlist.  An exprlist which
11949    contains only identifiers at the global level
11950    is a parmlist.  Otherwise, it is an exprlist.  */
11951
11952 int
11953 parmlist_is_exprlist (exprs)
11954      tree exprs;
11955 {
11956   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11957     return 0;
11958
11959   if (toplevel_bindings_p ())
11960     {
11961       /* At the global level, if these are all identifiers,
11962          then it is a parmlist.  */
11963       while (exprs)
11964         {
11965           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11966             return 1;
11967           exprs = TREE_CHAIN (exprs);
11968         }
11969       return 0;
11970     }
11971   return 1;
11972 }
11973
11974 /* Subroutine of start_function.  Ensure that each of the parameter
11975    types (as listed in PARMS) is complete, as is required for a
11976    function definition.  */
11977
11978 static void
11979 require_complete_types_for_parms (parms)
11980      tree parms;
11981 {
11982   for (; parms; parms = TREE_CHAIN (parms))
11983     {
11984       tree type = TREE_TYPE (parms);
11985
11986       /* Try to complete the TYPE.  */
11987       type = complete_type (type);
11988
11989       if (type == error_mark_node)
11990         continue;
11991
11992       if (!COMPLETE_TYPE_P (type))
11993         {
11994           if (DECL_NAME (parms))
11995             error ("parameter `%s' has incomplete type",
11996                    IDENTIFIER_POINTER (DECL_NAME (parms)));
11997           else
11998             error ("parameter has incomplete type");
11999           TREE_TYPE (parms) = error_mark_node;
12000         }
12001       else
12002         layout_decl (parms, 0);
12003     }
12004 }
12005
12006 /* Returns non-zero if T is a local variable.  */
12007
12008 int
12009 local_variable_p (t)
12010      tree t;
12011 {
12012   if ((TREE_CODE (t) == VAR_DECL
12013        /* A VAR_DECL with a context that is a _TYPE is a static data
12014           member.  */
12015        && !TYPE_P (CP_DECL_CONTEXT (t))
12016        /* Any other non-local variable must be at namespace scope.  */
12017        && !DECL_NAMESPACE_SCOPE_P (t))
12018       || (TREE_CODE (t) == PARM_DECL))
12019     return 1;
12020
12021   return 0;
12022 }
12023
12024 /* Returns non-zero if T is an automatic local variable or a label.
12025    (These are the declarations that need to be remapped when the code
12026    containing them is duplicated.)  */
12027
12028 int
12029 nonstatic_local_decl_p (t)
12030      tree t;
12031 {
12032   return ((local_variable_p (t) && !TREE_STATIC (t))
12033           || TREE_CODE (t) == LABEL_DECL
12034           || TREE_CODE (t) == RESULT_DECL);
12035 }
12036
12037 /* Like local_variable_p, but suitable for use as a tree-walking
12038    function.  */
12039
12040 static tree
12041 local_variable_p_walkfn (tp, walk_subtrees, data)
12042      tree *tp;
12043      int *walk_subtrees ATTRIBUTE_UNUSED;
12044      void *data ATTRIBUTE_UNUSED;
12045 {
12046   return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
12047           ? *tp : NULL_TREE);
12048 }
12049
12050 /* Check that ARG, which is a default-argument expression for a
12051    parameter DECL, is legal.  Returns ARG, or ERROR_MARK_NODE, if
12052    something goes wrong.  DECL may also be a _TYPE node, rather than a
12053    DECL, if there is no DECL available.  */
12054
12055 tree
12056 check_default_argument (decl, arg)
12057      tree decl;
12058      tree arg;
12059 {
12060   tree var;
12061   tree decl_type;
12062
12063   if (TREE_CODE (arg) == DEFAULT_ARG)
12064     /* We get a DEFAULT_ARG when looking at an in-class declaration
12065        with a default argument.  Ignore the argument for now; we'll
12066        deal with it after the class is complete.  */
12067     return arg;
12068
12069   if (processing_template_decl || uses_template_parms (arg))
12070     /* We don't do anything checking until instantiation-time.  Note
12071        that there may be uninstantiated arguments even for an
12072        instantiated function, since default arguments are not
12073        instantiated until they are needed.  */
12074     return arg;
12075
12076   if (TYPE_P (decl))
12077     {
12078       decl_type = decl;
12079       decl = NULL_TREE;
12080     }
12081   else
12082     decl_type = TREE_TYPE (decl);
12083
12084   if (arg == error_mark_node
12085       || decl == error_mark_node
12086       || TREE_TYPE (arg) == error_mark_node
12087       || decl_type == error_mark_node)
12088     /* Something already went wrong.  There's no need to check
12089        further.  */
12090     return error_mark_node;
12091
12092   /* [dcl.fct.default]
12093
12094      A default argument expression is implicitly converted to the
12095      parameter type.  */
12096   if (!TREE_TYPE (arg)
12097       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
12098     {
12099       if (decl)
12100         cp_error ("default argument for `%#D' has type `%T'",
12101                   decl, TREE_TYPE (arg));
12102       else
12103         cp_error ("default argument for parameter of type `%T' has type `%T'",
12104                   decl_type, TREE_TYPE (arg));
12105
12106       return error_mark_node;
12107     }
12108
12109   /* [dcl.fct.default]
12110
12111      Local variables shall not be used in default argument
12112      expressions.
12113
12114      The keyword `this' shall not be used in a default argument of a
12115      member function.  */
12116   var = walk_tree_without_duplicates (&arg, local_variable_p_walkfn,
12117                                       NULL);
12118   if (var)
12119     {
12120       cp_error ("default argument `%E' uses local variable `%D'",
12121                 arg, var);
12122       return error_mark_node;
12123     }
12124
12125   /* All is well.  */
12126   return arg;
12127 }
12128
12129 /* Decode the list of parameter types for a function type.
12130    Given the list of things declared inside the parens,
12131    return a list of types.
12132
12133    The list we receive can have three kinds of elements:
12134    an IDENTIFIER_NODE for names given without types,
12135    a TREE_LIST node for arguments given as typespecs or names with typespecs,
12136    or void_type_node, to mark the end of an argument list
12137    when additional arguments are not permitted (... was not used).
12138
12139    FUNCDEF_FLAG is nonzero for a function definition, 0 for
12140    a mere declaration.  A nonempty identifier-list gets an error message
12141    when FUNCDEF_FLAG is zero.
12142    If FUNCDEF_FLAG is 1, then parameter types must be complete.
12143    If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
12144
12145    If all elements of the input list contain types,
12146    we return a list of the types.
12147    If all elements contain no type (except perhaps a void_type_node
12148    at the end), we return a null list.
12149    If some have types and some do not, it is an error, and we
12150    return a null list.
12151
12152    Also set last_function_parms to either
12153    a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
12154    A list of names is converted to a chain of PARM_DECLs
12155    by store_parm_decls so that ultimately it is always a chain of decls.
12156
12157    Note that in C++, parameters can take default values.  These default
12158    values are in the TREE_PURPOSE field of the TREE_LIST.  It is
12159    an error to specify default values which are followed by parameters
12160    that have no default values, or an ELLIPSES.  For simplicities sake,
12161    only parameters which are specified with their types can take on
12162    default values.  */
12163
12164 static tree
12165 grokparms (first_parm, funcdef_flag)
12166      tree first_parm;
12167      int funcdef_flag;
12168 {
12169   tree result = NULL_TREE;
12170   tree decls = NULL_TREE;
12171
12172   if (first_parm != NULL_TREE
12173       && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
12174     {
12175       if (! funcdef_flag)
12176         pedwarn ("parameter names (without types) in function declaration");
12177       last_function_parms = first_parm;
12178       return NULL_TREE;
12179     }
12180   else if (first_parm != NULL_TREE
12181            && TREE_CODE (TREE_VALUE (first_parm)) != TREE_LIST
12182            && TREE_CODE (TREE_VALUE (first_parm)) != VOID_TYPE)
12183     my_friendly_abort (145);
12184   else
12185     {
12186       /* Types were specified.  This is a list of declarators
12187          each represented as a TREE_LIST node.  */
12188       register tree parm, chain;
12189       int any_init = 0, any_error = 0;
12190
12191       if (first_parm != NULL_TREE)
12192         {
12193           tree last_result = NULL_TREE;
12194           tree last_decl = NULL_TREE;
12195
12196           for (parm = first_parm; parm != NULL_TREE; parm = chain)
12197             {
12198               tree type = NULL_TREE, list_node = parm;
12199               register tree decl = TREE_VALUE (parm);
12200               tree init = TREE_PURPOSE (parm);
12201
12202               chain = TREE_CHAIN (parm);
12203               /* @@ weak defense against parse errors.  */
12204               if (TREE_CODE (decl) != VOID_TYPE
12205                   && TREE_CODE (decl) != TREE_LIST)
12206                 {
12207                   /* Give various messages as the need arises.  */
12208                   if (TREE_CODE (decl) == STRING_CST)
12209                     cp_error ("invalid string constant `%E'", decl);
12210                   else if (TREE_CODE (decl) == INTEGER_CST)
12211                     error ("invalid integer constant in parameter list, did you forget to give parameter name?");
12212                   continue;
12213                 }
12214
12215               if (TREE_CODE (decl) != VOID_TYPE)
12216                 {
12217                   decl = grokdeclarator (TREE_VALUE (decl),
12218                                          TREE_PURPOSE (decl),
12219                                          PARM, init != NULL_TREE,
12220                                          NULL_TREE);
12221                   if (! decl || TREE_TYPE (decl) == error_mark_node)
12222                     continue;
12223
12224                   /* Top-level qualifiers on the parameters are
12225                      ignored for function types.  */
12226                   type = TYPE_MAIN_VARIANT (TREE_TYPE (decl));
12227
12228                   if (TREE_CODE (type) == VOID_TYPE)
12229                     decl = void_type_node;
12230                   else if (TREE_CODE (type) == METHOD_TYPE)
12231                     {
12232                       if (DECL_NAME (decl))
12233                         /* Cannot use the decl here because
12234                            we don't have DECL_CONTEXT set up yet.  */
12235                         cp_error ("parameter `%D' invalidly declared method type",
12236                                   DECL_NAME (decl));
12237                       else
12238                         error ("parameter invalidly declared method type");
12239                       type = build_pointer_type (type);
12240                       TREE_TYPE (decl) = type;
12241                     }
12242                   else if (TREE_CODE (type) == OFFSET_TYPE)
12243                     {
12244                       if (DECL_NAME (decl))
12245                         cp_error ("parameter `%D' invalidly declared offset type",
12246                                   DECL_NAME (decl));
12247                       else
12248                         error ("parameter invalidly declared offset type");
12249                       type = build_pointer_type (type);
12250                       TREE_TYPE (decl) = type;
12251                     }
12252                   else if (abstract_virtuals_error (decl, type))
12253                     any_error = 1;  /* Seems like a good idea. */
12254                   else if (POINTER_TYPE_P (type))
12255                     {
12256                       tree t = type;
12257                       while (POINTER_TYPE_P (t)
12258                              || (TREE_CODE (t) == ARRAY_TYPE
12259                                  && TYPE_DOMAIN (t) != NULL_TREE))
12260                         t = TREE_TYPE (t);
12261                       if (TREE_CODE (t) == ARRAY_TYPE)
12262                         cp_error ("parameter type `%T' includes %s to array of unknown bound",
12263                                   type,
12264                                   TYPE_PTR_P (type) ? "pointer" : "reference");
12265                     }
12266                 }
12267
12268               if (TREE_CODE (decl) == VOID_TYPE)
12269                 {
12270                   if (result == NULL_TREE)
12271                     {
12272                       result = void_list_node;
12273                       last_result = result;
12274                     }
12275                   else
12276                     {
12277                       TREE_CHAIN (last_result) = void_list_node;
12278                       last_result = void_list_node;
12279                     }
12280                   if (chain
12281                       && (chain != void_list_node || TREE_CHAIN (chain)))
12282                     error ("`void' in parameter list must be entire list");
12283                   break;
12284                 }
12285
12286               /* Since there is a prototype, args are passed in their own types.  */
12287               DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
12288               if (PROMOTE_PROTOTYPES
12289                   && (TREE_CODE (type) == INTEGER_TYPE
12290                       || TREE_CODE (type) == ENUMERAL_TYPE)
12291                   && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
12292                 DECL_ARG_TYPE (decl) = integer_type_node;
12293               if (!any_error && init)
12294                 {
12295                   any_init++;
12296                   init = check_default_argument (decl, init);
12297                 }
12298               else
12299                 init = NULL_TREE;
12300
12301               if (decls == NULL_TREE)
12302                 {
12303                   decls = decl;
12304                   last_decl = decls;
12305                 }
12306               else
12307                 {
12308                   TREE_CHAIN (last_decl) = decl;
12309                   last_decl = decl;
12310                 }
12311               list_node = tree_cons (init, type, NULL_TREE);
12312               if (result == NULL_TREE)
12313                 {
12314                   result = list_node;
12315                   last_result = result;
12316                 }
12317               else
12318                 {
12319                   TREE_CHAIN (last_result) = list_node;
12320                   last_result = list_node;
12321                 }
12322             }
12323           if (last_result)
12324             TREE_CHAIN (last_result) = NULL_TREE;
12325           /* If there are no parameters, and the function does not end
12326              with `...', then last_decl will be NULL_TREE.  */
12327           if (last_decl != NULL_TREE)
12328             TREE_CHAIN (last_decl) = NULL_TREE;
12329         }
12330     }
12331
12332   last_function_parms = decls;
12333
12334   return result;
12335 }
12336
12337 /* Called from the parser to update an element of TYPE_ARG_TYPES for some
12338    FUNCTION_TYPE with the newly parsed version of its default argument, which
12339    was previously digested as text.  See snarf_defarg et al in lex.c.  */
12340
12341 void
12342 replace_defarg (arg, init)
12343      tree arg, init;
12344 {
12345   if (! processing_template_decl
12346       && ! can_convert_arg (TREE_VALUE (arg), TREE_TYPE (init), init))
12347     cp_pedwarn ("invalid type `%T' for default argument to `%T'",
12348                 TREE_TYPE (init), TREE_VALUE (arg));
12349   TREE_PURPOSE (arg) = init;
12350 }
12351 \f
12352 /* D is a constructor or overloaded `operator='.  Returns non-zero if
12353    D's arguments allow it to be a copy constructor, or copy assignment
12354    operator.  */
12355
12356 int
12357 copy_args_p (d)
12358      tree d;
12359 {
12360   tree t;
12361
12362   if (!DECL_FUNCTION_MEMBER_P (d))
12363     return 0;
12364
12365   t = FUNCTION_ARG_CHAIN (d);
12366   if (DECL_CONSTRUCTOR_P (d) && DECL_HAS_IN_CHARGE_PARM_P (d))
12367     t = TREE_CHAIN (t);
12368   if (t && TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
12369       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t)))
12370           == DECL_CONTEXT (d))
12371       && (TREE_CHAIN (t) == NULL_TREE
12372           || TREE_CHAIN (t) == void_list_node
12373           || TREE_PURPOSE (TREE_CHAIN (t))))
12374     return 1;
12375   return 0;
12376 }
12377
12378 /* These memoizing functions keep track of special properties which
12379    a class may have.  `grok_ctor_properties' notices whether a class
12380    has a constructor of the form X(X&), and also complains
12381    if the class has a constructor of the form X(X).
12382    `grok_op_properties' takes notice of the various forms of
12383    operator= which are defined, as well as what sorts of type conversion
12384    may apply.  Both functions take a FUNCTION_DECL as an argument.  */
12385
12386 int
12387 grok_ctor_properties (ctype, decl)
12388      tree ctype, decl;
12389 {
12390   tree parmtypes = FUNCTION_ARG_CHAIN (decl);
12391   tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
12392
12393   /* When a type has virtual baseclasses, a magical first int argument is
12394      added to any ctor so we can tell if the class has been initialized
12395      yet.  This could screw things up in this function, so we deliberately
12396      ignore the leading int if we're in that situation.  */
12397   if (DECL_HAS_IN_CHARGE_PARM_P (decl))
12398     {
12399       my_friendly_assert (parmtypes
12400                           && TREE_VALUE (parmtypes) == integer_type_node,
12401                           980529);
12402       parmtypes = TREE_CHAIN (parmtypes);
12403       parmtype = TREE_VALUE (parmtypes);
12404     }
12405
12406   /* [class.copy]
12407
12408      A non-template constructor for class X is a copy constructor if
12409      its first parameter is of type X&, const X&, volatile X& or const
12410      volatile X&, and either there are no other parameters or else all
12411      other parameters have default arguments.  */
12412   if (TREE_CODE (parmtype) == REFERENCE_TYPE
12413       && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype
12414       && (TREE_CHAIN (parmtypes) == NULL_TREE
12415           || TREE_CHAIN (parmtypes) == void_list_node
12416           || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
12417       && !(DECL_TEMPLATE_INSTANTIATION (decl)
12418            && is_member_template (DECL_TI_TEMPLATE (decl))))
12419     {
12420       TYPE_HAS_INIT_REF (ctype) = 1;
12421       if (CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12422         TYPE_HAS_CONST_INIT_REF (ctype) = 1;
12423     }
12424   /* [class.copy]
12425
12426      A declaration of a constructor for a class X is ill-formed if its
12427      first parameter is of type (optionally cv-qualified) X and either
12428      there are no other parameters or else all other parameters have
12429      default arguments.
12430
12431      We *don't* complain about member template instantiations that
12432      have this form, though; they can occur as we try to decide what
12433      constructor to use during overload resolution.  Since overload
12434      resolution will never prefer such a constructor to the
12435      non-template copy constructor (which is either explicitly or
12436      implicitly defined), there's no need to worry about their
12437      existence.  Theoretically, they should never even be
12438      instantiated, but that's hard to forestall.  */
12439   else if (TYPE_MAIN_VARIANT (parmtype) == ctype
12440            && (TREE_CHAIN (parmtypes) == NULL_TREE
12441                || TREE_CHAIN (parmtypes) == void_list_node
12442                || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
12443            && !(DECL_TEMPLATE_INSTANTIATION (decl)
12444                 && is_member_template (DECL_TI_TEMPLATE (decl))))
12445     {
12446       cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
12447                 ctype, ctype);
12448       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
12449       return 0;
12450     }
12451   else if (TREE_CODE (parmtype) == VOID_TYPE
12452            || TREE_PURPOSE (parmtypes) != NULL_TREE)
12453     TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
12454
12455   return 1;
12456 }
12457
12458 /* An operator with this code is unary, but can also be binary.  */
12459
12460 static int
12461 ambi_op_p (code)
12462      enum tree_code code;
12463 {
12464   return (code == INDIRECT_REF
12465           || code == ADDR_EXPR
12466           || code == CONVERT_EXPR
12467           || code == NEGATE_EXPR
12468           || code == PREINCREMENT_EXPR
12469           || code == PREDECREMENT_EXPR);
12470 }
12471
12472 /* An operator with this name can only be unary.  */
12473
12474 static int
12475 unary_op_p (code)
12476      enum tree_code code;
12477 {
12478   return (code == TRUTH_NOT_EXPR
12479           || code == BIT_NOT_EXPR
12480           || code == COMPONENT_REF
12481           || code == TYPE_EXPR);
12482 }
12483
12484 /* Do a little sanity-checking on how they declared their operator.  */
12485
12486 void
12487 grok_op_properties (decl, virtualp, friendp)
12488      tree decl;
12489      int virtualp, friendp;
12490 {
12491   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
12492   tree argtype;
12493   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
12494   tree name = DECL_NAME (decl);
12495   enum tree_code operator_code;
12496   int arity;
12497
12498   /* Count the number of arguments.  */
12499   for (argtype = argtypes, arity = 0;
12500        argtype && argtype != void_list_node;
12501        argtype = TREE_CHAIN (argtype))
12502     ++arity;
12503
12504   if (current_class_type == NULL_TREE)
12505     friendp = 1;
12506
12507   if (DECL_CONV_FN_P (decl))
12508     operator_code = TYPE_EXPR;
12509   else
12510     do
12511       {
12512 #define DEF_OPERATOR(NAME, CODE, NEW_MANGLING, OLD_MANGING, ARITY, ASSN_P)  \
12513         if (ansi_opname (CODE) == name)                                     \
12514           {                                                                 \
12515             operator_code = CODE;                                           \
12516             break;                                                          \
12517           }                                                                 \
12518         else if (ansi_assopname (CODE) == name)                             \
12519           {                                                                 \
12520             operator_code = CODE;                                           \
12521             DECL_ASSIGNMENT_OPERATOR_P (decl) = 1;                          \
12522             break;                                                          \
12523           }
12524
12525 #include "operators.def"
12526 #undef DEF_OPERATOR
12527
12528         my_friendly_abort (20000527);
12529       }
12530     while (0);
12531   my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526);
12532   SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12533
12534   if (! friendp)
12535     {
12536       switch (operator_code)
12537         {
12538         case CALL_EXPR:
12539           TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
12540           break;
12541
12542         case ARRAY_REF:
12543           TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
12544           break;
12545
12546         case COMPONENT_REF:
12547         case MEMBER_REF:
12548           TYPE_OVERLOADS_ARROW (current_class_type) = 1;
12549           break;
12550
12551         case NEW_EXPR:
12552           TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
12553           break;
12554
12555         case DELETE_EXPR:
12556           TYPE_GETS_DELETE (current_class_type) |= 1;
12557           break;
12558
12559         case VEC_NEW_EXPR:
12560           TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
12561           break;
12562
12563         case VEC_DELETE_EXPR:
12564           TYPE_GETS_DELETE (current_class_type) |= 2;
12565           break;
12566
12567         default:
12568           break;
12569         }
12570     }
12571
12572   if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
12573     {
12574       /* When the compiler encounters the definition of A::operator new, it
12575          doesn't look at the class declaration to find out if it's static.  */
12576       if (methodp)
12577         revert_static_member_fn (decl);
12578
12579       /* Take care of function decl if we had syntax errors.  */
12580       if (argtypes == NULL_TREE)
12581         TREE_TYPE (decl)
12582           = build_function_type (ptr_type_node,
12583                                  hash_tree_chain (integer_type_node,
12584                                                   void_list_node));
12585       else
12586         TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12587     }
12588   else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
12589     {
12590       if (methodp)
12591         revert_static_member_fn (decl);
12592
12593       if (argtypes == NULL_TREE)
12594         TREE_TYPE (decl)
12595           = build_function_type (void_type_node,
12596                                  hash_tree_chain (ptr_type_node,
12597                                                   void_list_node));
12598       else
12599         TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12600     }
12601   else
12602     {
12603       /* An operator function must either be a non-static member function
12604          or have at least one parameter of a class, a reference to a class,
12605          an enumeration, or a reference to an enumeration.  13.4.0.6 */
12606       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12607         {
12608           if (operator_code == TYPE_EXPR
12609               || operator_code == CALL_EXPR
12610               || operator_code == COMPONENT_REF
12611               || operator_code == ARRAY_REF
12612               || operator_code == NOP_EXPR)
12613             cp_error ("`%D' must be a nonstatic member function", decl);
12614           else
12615             {
12616               tree p = argtypes;
12617
12618               if (DECL_STATIC_FUNCTION_P (decl))
12619                 cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
12620
12621               if (p)
12622                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12623                   {
12624                     tree arg = TREE_VALUE (p);
12625                     if (TREE_CODE (arg) == REFERENCE_TYPE)
12626                       arg = TREE_TYPE (arg);
12627
12628                     /* This lets bad template code slip through.  */
12629                     if (IS_AGGR_TYPE (arg)
12630                         || TREE_CODE (arg) == ENUMERAL_TYPE
12631                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12632                         || TREE_CODE (arg) == BOUND_TEMPLATE_TEMPLATE_PARM)
12633                       goto foundaggr;
12634                   }
12635               cp_error
12636                 ("`%D' must have an argument of class or enumerated type",
12637                  decl);
12638             foundaggr:
12639               ;
12640             }
12641         }
12642
12643       if (operator_code == CALL_EXPR)
12644         return;                 /* No restrictions on args. */
12645
12646       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12647         {
12648           tree t = TREE_TYPE (name);
12649           if (! friendp)
12650             {
12651               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12652               const char *what = 0;
12653
12654               if (ref)
12655                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12656
12657               if (TREE_CODE (t) == VOID_TYPE)
12658                 what = "void";
12659               else if (t == current_class_type)
12660                 what = "the same type";
12661               /* Don't force t to be complete here.  */
12662               else if (IS_AGGR_TYPE (t)
12663                        && COMPLETE_TYPE_P (t)
12664                        && DERIVED_FROM_P (t, current_class_type))
12665                 what = "a base class";
12666
12667               if (what)
12668                 warning ("conversion to %s%s will never use a type conversion operator",
12669                          ref ? "a reference to " : "", what);
12670             }
12671         }
12672
12673       if (DECL_ASSIGNMENT_OPERATOR_P (decl)
12674           && operator_code == NOP_EXPR)
12675         {
12676           tree parmtype;
12677
12678           if (arity != 2 && methodp)
12679             {
12680               cp_error ("`%D' must take exactly one argument", decl);
12681               return;
12682             }
12683           parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
12684
12685           /* [class.copy]
12686
12687              A user-declared copy assignment operator X::operator= is
12688              a non-static non-template member function of class X with
12689              exactly one parameter of type X, X&, const X&, volatile
12690              X& or const volatile X&.  */
12691           if (copy_assignment_arg_p (parmtype, virtualp)
12692               && !(DECL_TEMPLATE_INSTANTIATION (decl)
12693                    && is_member_template (DECL_TI_TEMPLATE (decl)))
12694               && ! friendp)
12695             {
12696               TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
12697               if (TREE_CODE (parmtype) != REFERENCE_TYPE
12698                   || CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12699                 TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
12700             }
12701         }
12702       else if (operator_code == COND_EXPR)
12703         {
12704           /* 13.4.0.3 */
12705           cp_error ("ISO C++ prohibits overloading operator ?:");
12706         }
12707       else if (ambi_op_p (operator_code))
12708         {
12709           if (arity == 1)
12710             /* We pick the one-argument operator codes by default, so
12711                we don't have to change anything.  */
12712             ;
12713           else if (arity == 2)
12714             {
12715               /* If we thought this was a unary operator, we now know
12716                  it to be a binary operator.  */
12717               switch (operator_code)
12718                 {
12719                 case INDIRECT_REF:
12720                   operator_code = MULT_EXPR;
12721                   break;
12722
12723                 case ADDR_EXPR:
12724                   operator_code = BIT_AND_EXPR;
12725                   break;
12726
12727                 case CONVERT_EXPR:
12728                   operator_code = PLUS_EXPR;
12729                   break;
12730
12731                 case NEGATE_EXPR:
12732                   operator_code = MINUS_EXPR;
12733                   break;
12734
12735                 case PREINCREMENT_EXPR:
12736                   operator_code = POSTINCREMENT_EXPR;
12737                   break;
12738
12739                 case PREDECREMENT_EXPR:
12740                   operator_code = POSTDECREMENT_EXPR;
12741                   break;
12742
12743                 default:
12744                   my_friendly_abort (20000527);
12745                 }
12746
12747               SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12748
12749               if ((operator_code == POSTINCREMENT_EXPR
12750                    || operator_code == POSTDECREMENT_EXPR)
12751                   && ! processing_template_decl
12752                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12753                 {
12754                   if (methodp)
12755                     cp_error ("postfix `%D' must take `int' as its argument",
12756                               decl);
12757                   else
12758                     cp_error
12759                       ("postfix `%D' must take `int' as its second argument",
12760                        decl);
12761                 }
12762             }
12763           else
12764             {
12765               if (methodp)
12766                 cp_error ("`%D' must take either zero or one argument", decl);
12767               else
12768                 cp_error ("`%D' must take either one or two arguments", decl);
12769             }
12770
12771           /* More Effective C++ rule 6.  */
12772           if (warn_ecpp
12773               && (operator_code == POSTINCREMENT_EXPR
12774                   || operator_code == POSTDECREMENT_EXPR
12775                   || operator_code == PREINCREMENT_EXPR
12776                   || operator_code == PREDECREMENT_EXPR))
12777             {
12778               tree arg = TREE_VALUE (argtypes);
12779               tree ret = TREE_TYPE (TREE_TYPE (decl));
12780               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12781                 arg = TREE_TYPE (arg);
12782               arg = TYPE_MAIN_VARIANT (arg);
12783               if (operator_code == PREINCREMENT_EXPR
12784                   || operator_code == PREDECREMENT_EXPR)
12785                 {
12786                   if (TREE_CODE (ret) != REFERENCE_TYPE
12787                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12788                                        arg))
12789                     cp_warning ("prefix `%D' should return `%T'", decl,
12790                                 build_reference_type (arg));
12791                 }
12792               else
12793                 {
12794                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12795                     cp_warning ("postfix `%D' should return `%T'", decl, arg);
12796                 }
12797             }
12798         }
12799       else if (unary_op_p (operator_code))
12800         {
12801           if (arity != 1)
12802             {
12803               if (methodp)
12804                 cp_error ("`%D' must take `void'", decl);
12805               else
12806                 cp_error ("`%D' must take exactly one argument", decl);
12807             }
12808         }
12809       else /* if (binary_op_p (operator_code)) */
12810         {
12811           if (arity != 2)
12812             {
12813               if (methodp)
12814                 cp_error ("`%D' must take exactly one argument", decl);
12815               else
12816                 cp_error ("`%D' must take exactly two arguments", decl);
12817             }
12818
12819           /* More Effective C++ rule 7.  */
12820           if (warn_ecpp
12821               && (operator_code == TRUTH_ANDIF_EXPR
12822                   || operator_code == TRUTH_ORIF_EXPR
12823                   || operator_code == COMPOUND_EXPR))
12824             cp_warning ("user-defined `%D' always evaluates both arguments",
12825                         decl);
12826         }
12827
12828       /* Effective C++ rule 23.  */
12829       if (warn_ecpp
12830           && arity == 2
12831           && (operator_code == PLUS_EXPR
12832               || operator_code == MINUS_EXPR
12833               || operator_code == TRUNC_DIV_EXPR
12834               || operator_code == MULT_EXPR)
12835           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12836         cp_warning ("`%D' should return by value", decl);
12837
12838       /* 13.4.0.8 */
12839       for (; argtypes && argtypes != void_list_node;
12840           argtypes = TREE_CHAIN (argtypes))
12841         if (TREE_PURPOSE (argtypes))
12842           {
12843             TREE_PURPOSE (argtypes) = NULL_TREE;
12844             if (operator_code == POSTINCREMENT_EXPR
12845                 || operator_code == POSTDECREMENT_EXPR)
12846               {
12847                 if (pedantic)
12848                   cp_pedwarn ("`%D' cannot have default arguments", decl);
12849               }
12850             else
12851               cp_error ("`%D' cannot have default arguments", decl);
12852           }
12853
12854     }
12855 }
12856 \f
12857 static const char *
12858 tag_name (code)
12859      enum tag_types code;
12860 {
12861   switch (code)
12862     {
12863     case record_type:
12864       return "struct";
12865     case class_type:
12866       return "class";
12867     case union_type:
12868       return "union ";
12869     case enum_type:
12870       return "enum";
12871     default:
12872       my_friendly_abort (981122);
12873     }
12874 }
12875
12876 /* Get the struct, enum or union (CODE says which) with tag NAME.
12877    Define the tag as a forward-reference if it is not defined.
12878
12879    C++: If a class derivation is given, process it here, and report
12880    an error if multiple derivation declarations are not identical.
12881
12882    If this is a definition, come in through xref_tag and only look in
12883    the current frame for the name (since C++ allows new names in any
12884    scope.)  */
12885
12886 tree
12887 xref_tag (code_type_node, name, globalize)
12888      tree code_type_node;
12889      tree name;
12890      int globalize;
12891 {
12892   enum tag_types tag_code;
12893   enum tree_code code;
12894   register tree ref, t;
12895   struct binding_level *b = current_binding_level;
12896   int got_type = 0;
12897   tree attributes = NULL_TREE;
12898   tree context = NULL_TREE;
12899
12900   /* If we are called from the parser, code_type_node will sometimes be a
12901      TREE_LIST.  This indicates that the user wrote
12902      "class __attribute__ ((foo)) bar".  Extract the attributes so we can
12903      use them later.  */
12904   if (TREE_CODE (code_type_node) == TREE_LIST)
12905     {
12906       attributes = TREE_PURPOSE (code_type_node);
12907       code_type_node = TREE_VALUE (code_type_node);
12908     }
12909
12910   tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12911   switch (tag_code)
12912     {
12913     case record_type:
12914     case class_type:
12915       code = RECORD_TYPE;
12916       break;
12917     case union_type:
12918       code = UNION_TYPE;
12919       break;
12920     case enum_type:
12921       code = ENUMERAL_TYPE;
12922       break;
12923     default:
12924       my_friendly_abort (18);
12925     }
12926
12927   /* If a cross reference is requested, look up the type
12928      already defined for this tag and return it.  */
12929   if (TYPE_P (name))
12930     {
12931       t = name;
12932       name = TYPE_IDENTIFIER (t);
12933       got_type = 1;
12934     }
12935   else
12936     t = IDENTIFIER_TYPE_VALUE (name);
12937
12938   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12939       && TREE_CODE (t) != BOUND_TEMPLATE_TEMPLATE_PARM)
12940     t = NULL_TREE;
12941
12942   if (! globalize)
12943     {
12944       /* If we know we are defining this tag, only look it up in
12945          this scope and don't try to find it as a type.  */
12946       ref = lookup_tag (code, name, b, 1);
12947     }
12948   else
12949     {
12950       if (t)
12951         {
12952           /* [dcl.type.elab] If the identifier resolves to a
12953              typedef-name or a template type-parameter, the
12954              elaborated-type-specifier is ill-formed.  */
12955           if (t != TYPE_MAIN_VARIANT (t)
12956               || (CLASS_TYPE_P (t) && TYPE_WAS_ANONYMOUS (t)))
12957             cp_pedwarn ("using typedef-name `%D' after `%s'",
12958                         TYPE_NAME (t), tag_name (tag_code));
12959           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12960             cp_error ("using template type parameter `%T' after `%s'",
12961                       t, tag_name (tag_code));
12962
12963           ref = t;
12964         }
12965       else
12966         ref = lookup_tag (code, name, b, 0);
12967
12968       if (! ref)
12969         {
12970           /* Try finding it as a type declaration.  If that wins,
12971              use it.  */
12972           ref = lookup_name (name, 1);
12973
12974           if (ref != NULL_TREE
12975               && processing_template_decl
12976               && DECL_CLASS_TEMPLATE_P (ref)
12977               && template_class_depth (current_class_type) == 0)
12978             /* Since GLOBALIZE is true, we're declaring a global
12979                template, so we want this type.  */
12980             ref = DECL_TEMPLATE_RESULT (ref);
12981
12982           if (ref && TREE_CODE (ref) == TYPE_DECL
12983               && TREE_CODE (TREE_TYPE (ref)) == code)
12984             ref = TREE_TYPE (ref);
12985           else
12986             ref = NULL_TREE;
12987         }
12988
12989       if (ref && current_class_type
12990           && template_class_depth (current_class_type)
12991           && PROCESSING_REAL_TEMPLATE_DECL_P ())
12992         {
12993           /* Since GLOBALIZE is non-zero, we are not looking at a
12994              definition of this tag.  Since, in addition, we are currently
12995              processing a (member) template declaration of a template
12996              class, we must be very careful; consider:
12997
12998                template <class X>
12999                struct S1
13000
13001                template <class U>
13002                struct S2
13003                { template <class V>
13004                friend struct S1; };
13005
13006              Here, the S2::S1 declaration should not be confused with the
13007              outer declaration.  In particular, the inner version should
13008              have a template parameter of level 2, not level 1.  This
13009              would be particularly important if the member declaration
13010              were instead:
13011
13012                template <class V = U> friend struct S1;
13013
13014              say, when we should tsubst into `U' when instantiating
13015              S2.  On the other hand, when presented with:
13016
13017                  template <class T>
13018                  struct S1 {
13019                    template <class U>
13020                    struct S2 {};
13021                    template <class U>
13022                    friend struct S2;
13023                  };
13024
13025               we must find the inner binding eventually.  We
13026               accomplish this by making sure that the new type we
13027               create to represent this declaration has the right
13028               TYPE_CONTEXT.  */
13029           context = TYPE_CONTEXT (ref);
13030           ref = NULL_TREE;
13031         }
13032     }
13033
13034   if (! ref)
13035     {
13036       /* If no such tag is yet defined, create a forward-reference node
13037          and record it as the "definition".
13038          When a real declaration of this type is found,
13039          the forward-reference will be altered into a real type.  */
13040       if (code == ENUMERAL_TYPE)
13041         {
13042           cp_error ("use of enum `%#D' without previous declaration", name);
13043
13044           ref = make_node (ENUMERAL_TYPE);
13045
13046           /* Give the type a default layout like unsigned int
13047              to avoid crashing if it does not get defined.  */
13048           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
13049           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
13050           TYPE_USER_ALIGN (ref) = 0;
13051           TREE_UNSIGNED (ref) = 1;
13052           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
13053           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
13054           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
13055
13056           /* Enable us to recognize when a type is created in class context.
13057              To do nested classes correctly, this should probably be cleared
13058              out when we leave this classes scope.  Currently this in only
13059              done in `start_enum'.  */
13060
13061           pushtag (name, ref, globalize);
13062         }
13063       else
13064         {
13065           struct binding_level *old_b = class_binding_level;
13066
13067           ref = make_aggr_type (code);
13068           TYPE_CONTEXT (ref) = context;
13069
13070 #ifdef NONNESTED_CLASSES
13071           /* Class types don't nest the way enums do.  */
13072           class_binding_level = (struct binding_level *)0;
13073 #endif
13074           pushtag (name, ref, globalize);
13075           class_binding_level = old_b;
13076         }
13077     }
13078   else
13079     {
13080       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
13081         redeclare_class_template (ref, current_template_parms);
13082     }
13083
13084   /* Until the type is defined, tentatively accept whatever
13085      structure tag the user hands us.  */
13086   if (!COMPLETE_TYPE_P (ref)
13087       && ref != current_class_type
13088       /* Have to check this, in case we have contradictory tag info.  */
13089       && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
13090     {
13091       if (tag_code == class_type)
13092         CLASSTYPE_DECLARED_CLASS (ref) = 1;
13093       else if (tag_code == record_type)
13094         CLASSTYPE_DECLARED_CLASS (ref) = 0;
13095     }
13096
13097   TREE_TYPE (ref) = attributes;
13098
13099   return ref;
13100 }
13101
13102 tree
13103 xref_tag_from_type (old, id, globalize)
13104      tree old, id;
13105      int globalize;
13106 {
13107   tree code_type_node;
13108
13109   if (TREE_CODE (old) == RECORD_TYPE)
13110     code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
13111                       ? class_type_node : record_type_node);
13112   else
13113     code_type_node = union_type_node;
13114
13115   if (id == NULL_TREE)
13116     id = TYPE_IDENTIFIER (old);
13117
13118   return xref_tag (code_type_node, id, globalize);
13119 }
13120
13121 /* REF is a type (named NAME), for which we have just seen some
13122    baseclasses.  BINFO is a list of those baseclasses; the
13123    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
13124    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
13125    struct, or union.  */
13126
13127 void
13128 xref_basetypes (code_type_node, name, ref, binfo)
13129      tree code_type_node;
13130      tree name, ref;
13131      tree binfo;
13132 {
13133   /* In the declaration `A : X, Y, ... Z' we mark all the types
13134      (A, X, Y, ..., Z) so we can check for duplicates.  */
13135   tree binfos;
13136   tree base;
13137
13138   int i, len;
13139   enum tag_types tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
13140
13141   if (tag_code == union_type)
13142     {
13143       cp_error ("derived union `%T' invalid", ref);
13144       return;
13145     }
13146
13147   len = list_length (binfo);
13148
13149   /* First, make sure that any templates in base-classes are
13150      instantiated.  This ensures that if we call ourselves recursively
13151      we do not get confused about which classes are marked and which
13152      are not.  */
13153   for (base = binfo; base; base = TREE_CHAIN (base))
13154     complete_type (TREE_VALUE (base));
13155
13156   SET_CLASSTYPE_MARKED (ref);
13157   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
13158
13159   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
13160     {
13161       /* The base of a derived struct is public by default.  */
13162       int via_public
13163         = (TREE_PURPOSE (binfo) == access_public_node
13164            || TREE_PURPOSE (binfo) == access_public_virtual_node
13165            || (tag_code != class_type
13166                && (TREE_PURPOSE (binfo) == access_default_node
13167                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
13168       int via_protected
13169         = (TREE_PURPOSE (binfo) == access_protected_node
13170            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
13171       int via_virtual
13172         = (TREE_PURPOSE (binfo) == access_private_virtual_node
13173            || TREE_PURPOSE (binfo) == access_protected_virtual_node
13174            || TREE_PURPOSE (binfo) == access_public_virtual_node
13175            || TREE_PURPOSE (binfo) == access_default_virtual_node);
13176       tree basetype = TREE_VALUE (binfo);
13177       tree base_binfo;
13178
13179       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
13180         basetype = TREE_TYPE (basetype);
13181       if (!basetype
13182           || (TREE_CODE (basetype) != RECORD_TYPE
13183               && TREE_CODE (basetype) != TYPENAME_TYPE
13184               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
13185               && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM))
13186         {
13187           cp_error ("base type `%T' fails to be a struct or class type",
13188                     TREE_VALUE (binfo));
13189           continue;
13190         }
13191
13192       GNU_xref_hier (name, basetype, via_public, via_virtual, 0);
13193
13194       /* This code replaces similar code in layout_basetypes.
13195          We put the complete_type first for implicit `typename'.  */
13196       if (!COMPLETE_TYPE_P (basetype)
13197           && ! (current_template_parms && uses_template_parms (basetype)))
13198         {
13199           cp_error ("base class `%T' has incomplete type", basetype);
13200           continue;
13201         }
13202       else
13203         {
13204           if (CLASSTYPE_MARKED (basetype))
13205             {
13206               if (basetype == ref)
13207                 cp_error ("recursive type `%T' undefined", basetype);
13208               else
13209                 cp_error ("duplicate base type `%T' invalid", basetype);
13210               continue;
13211             }
13212
13213           if (TYPE_FOR_JAVA (basetype)
13214               && (current_lang_stack
13215                   == &VARRAY_TREE (current_lang_base, 0)))
13216             TYPE_FOR_JAVA (ref) = 1;
13217
13218           /* Note that the BINFO records which describe individual
13219              inheritances are *not* shared in the lattice!  They
13220              cannot be shared because a given baseclass may be
13221              inherited with different `accessibility' by different
13222              derived classes.  (Each BINFO record describing an
13223              individual inheritance contains flags which say what
13224              the `accessibility' of that particular inheritance is.)  */
13225
13226           base_binfo
13227             = make_binfo (size_zero_node, basetype,
13228                           CLASS_TYPE_P (basetype)
13229                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
13230                           CLASS_TYPE_P (basetype)
13231                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
13232
13233           TREE_VEC_ELT (binfos, i) = base_binfo;
13234           TREE_VIA_PUBLIC (base_binfo) = via_public;
13235           TREE_VIA_PROTECTED (base_binfo) = via_protected;
13236           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
13237           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
13238
13239           /* We need to unshare the binfos now so that lookups during class
13240              definition work.  */
13241           unshare_base_binfos (base_binfo);
13242
13243           SET_CLASSTYPE_MARKED (basetype);
13244
13245           /* We are free to modify these bits because they are meaningless
13246              at top level, and BASETYPE is a top-level type.  */
13247           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
13248             {
13249               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
13250               /* Converting to a virtual base class requires looking
13251                  up the offset of the virtual base.  */
13252               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13253             }
13254
13255           if (CLASS_TYPE_P (basetype))
13256             {
13257               TYPE_HAS_NEW_OPERATOR (ref)
13258                 |= TYPE_HAS_NEW_OPERATOR (basetype);
13259               TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
13260                 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
13261               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
13262               /* If the base-class uses multiple inheritance, so do we.  */
13263               TYPE_USES_MULTIPLE_INHERITANCE (ref)
13264                 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
13265               /* Likewise, if converting to a base of the base may require
13266                  code, then we may need to generate code to convert to a
13267                  base as well.  */
13268               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
13269                 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
13270             }
13271
13272           i += 1;
13273         }
13274     }
13275   if (i)
13276     TREE_VEC_LENGTH (binfos) = i;
13277   else
13278     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
13279
13280   if (i > 1)
13281     {
13282       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
13283       /* If there is more than one non-empty they cannot be at the same
13284          address.  */
13285       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13286     }
13287
13288   /* Unmark all the types.  */
13289   while (--i >= 0)
13290     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
13291   CLEAR_CLASSTYPE_MARKED (ref);
13292
13293   /* Now that we know all the base-classes, set up the list of virtual
13294      bases.  */
13295   get_vbase_types (ref);
13296 }
13297
13298 \f
13299 /* Begin compiling the definition of an enumeration type.
13300    NAME is its name (or null if anonymous).
13301    Returns the type object, as yet incomplete.
13302    Also records info about it so that build_enumerator
13303    may be used to declare the individual values as they are read.  */
13304
13305 tree
13306 start_enum (name)
13307      tree name;
13308 {
13309   register tree enumtype = NULL_TREE;
13310   struct binding_level *b = current_binding_level;
13311
13312   /* If this is the real definition for a previous forward reference,
13313      fill in the contents in the same object that used to be the
13314      forward reference.  */
13315
13316   if (name != NULL_TREE)
13317     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
13318
13319   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
13320     {
13321       cp_error ("multiple definition of `%#T'", enumtype);
13322       cp_error_at ("previous definition here", enumtype);
13323       /* Clear out TYPE_VALUES, and start again.  */
13324       TYPE_VALUES (enumtype) = NULL_TREE;
13325     }
13326   else
13327     {
13328       enumtype = make_node (ENUMERAL_TYPE);
13329       pushtag (name, enumtype, 0);
13330     }
13331
13332   if (current_class_type)
13333     TREE_ADDRESSABLE (b->tags) = 1;
13334
13335   GNU_xref_decl (current_function_decl, enumtype);
13336   return enumtype;
13337 }
13338
13339 /* After processing and defining all the values of an enumeration type,
13340    install their decls in the enumeration type and finish it off.
13341    ENUMTYPE is the type object and VALUES a list of name-value pairs.
13342    Returns ENUMTYPE.  */
13343
13344 tree
13345 finish_enum (enumtype)
13346      tree enumtype;
13347 {
13348   register tree minnode = NULL_TREE, maxnode = NULL_TREE;
13349   /* Calculate the maximum value of any enumerator in this type.  */
13350
13351   tree values = TYPE_VALUES (enumtype);
13352   if (values)
13353     {
13354       tree pair;
13355
13356       for (pair = values; pair; pair = TREE_CHAIN (pair))
13357         {
13358           tree decl;
13359           tree value;
13360
13361           /* The TREE_VALUE is a CONST_DECL for this enumeration
13362              constant.  */
13363           decl = TREE_VALUE (pair);
13364
13365           /* [dcl.enum]
13366
13367              Following the closing brace of an enum-specifier, each
13368              enumerator has the type of its enumeration.  Prior to the
13369              closing brace, the type of each enumerator is the type of
13370              its initializing value.  */
13371           TREE_TYPE (decl) = enumtype;
13372
13373           /* The DECL_INITIAL will be NULL if we are processing a
13374              template declaration and this enumeration constant had no
13375              explicit initializer.  */
13376           value = DECL_INITIAL (decl);
13377           if (value && !processing_template_decl)
13378             {
13379               /* Set the TREE_TYPE for the VALUE as well.  That's so
13380                  that when we call decl_constant_value we get an
13381                  entity of the right type (but with the constant
13382                  value).  Since we shouldn't ever call
13383                  decl_constant_value on a template type, there's no
13384                  reason to do that when processing_template_decl.
13385                  And, if the expression is something like a
13386                  TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will
13387                  wreak havoc on the intended type of the expression.
13388
13389                  Of course, there's also no point in trying to compute
13390                  minimum or maximum values if we're in a template.  */
13391               TREE_TYPE (value) = enumtype;
13392
13393               if (!minnode)
13394                 minnode = maxnode = value;
13395               else if (tree_int_cst_lt (maxnode, value))
13396                 maxnode = value;
13397               else if (tree_int_cst_lt (value, minnode))
13398                 minnode = value;
13399             }
13400
13401           if (processing_template_decl)
13402             /* If this is just a template, leave the CONST_DECL
13403                alone.  That way tsubst_copy will find CONST_DECLs for
13404                CONST_DECLs, and not INTEGER_CSTs.  */
13405             ;
13406           else
13407             /* In the list we're building up, we want the enumeration
13408                values, not the CONST_DECLs.  */
13409             TREE_VALUE (pair) = value;
13410         }
13411     }
13412   else
13413     maxnode = minnode = integer_zero_node;
13414
13415   TYPE_VALUES (enumtype) = nreverse (values);
13416
13417   if (processing_template_decl)
13418     {
13419       tree scope = current_scope ();
13420       if (scope && TREE_CODE (scope) == FUNCTION_DECL)
13421         add_stmt (build_min (TAG_DEFN, enumtype));
13422     }
13423   else
13424     {
13425       int unsignedp = tree_int_cst_sgn (minnode) >= 0;
13426       int lowprec = min_precision (minnode, unsignedp);
13427       int highprec = min_precision (maxnode, unsignedp);
13428       int precision = MAX (lowprec, highprec);
13429       tree tem;
13430
13431       TYPE_SIZE (enumtype) = NULL_TREE;
13432
13433       /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
13434
13435       TYPE_PRECISION (enumtype) = precision;
13436       if (unsignedp)
13437         fixup_unsigned_type (enumtype);
13438       else
13439         fixup_signed_type (enumtype);
13440
13441       if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
13442         /* Use the width of the narrowest normal C type which is wide
13443            enough.  */
13444         TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
13445                                                     (precision, 1));
13446       else
13447         TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
13448
13449       TYPE_SIZE (enumtype) = 0;
13450       layout_type (enumtype);
13451
13452       /* Fix up all variant types of this enum type.  */
13453       for (tem = TYPE_MAIN_VARIANT (enumtype); tem;
13454            tem = TYPE_NEXT_VARIANT (tem))
13455         {
13456           TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
13457           TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
13458           TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
13459           TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
13460           TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
13461           TYPE_MODE (tem) = TYPE_MODE (enumtype);
13462           TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
13463           TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
13464           TYPE_USER_ALIGN (tem) = TYPE_USER_ALIGN (enumtype);
13465           TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
13466         }
13467
13468       /* Finish debugging output for this type.  */
13469       rest_of_type_compilation (enumtype, namespace_bindings_p ());
13470     }
13471
13472   return enumtype;
13473 }
13474
13475 /* Build and install a CONST_DECL for an enumeration constant of the
13476    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13477    Assignment of sequential values by default is handled here.  */
13478
13479 void
13480 build_enumerator (name, value, enumtype)
13481      tree name;
13482      tree value;
13483      tree enumtype;
13484 {
13485   tree decl;
13486   tree context;
13487   tree type;
13488   tree values;
13489
13490   /* Remove no-op casts from the value.  */
13491   if (value)
13492     STRIP_TYPE_NOPS (value);
13493
13494   if (! processing_template_decl)
13495     {
13496       /* Validate and default VALUE.  */
13497       if (value != NULL_TREE)
13498         {
13499           value = decl_constant_value (value);
13500
13501           if (TREE_CODE (value) == INTEGER_CST)
13502             {
13503               value = default_conversion (value);
13504               constant_expression_warning (value);
13505             }
13506           else
13507             {
13508               cp_error ("enumerator value for `%D' not integer constant", name);
13509               value = NULL_TREE;
13510             }
13511         }
13512
13513       /* Default based on previous value.  */
13514       if (value == NULL_TREE && ! processing_template_decl)
13515         {
13516           tree prev_value;
13517
13518           if (TYPE_VALUES (enumtype))
13519             {
13520               /* The next value is the previous value ... */
13521               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
13522               /* ... plus one.  */
13523               value = cp_build_binary_op (PLUS_EXPR,
13524                                           prev_value,
13525                                           integer_one_node);
13526
13527               if (tree_int_cst_lt (value, prev_value))
13528                 cp_error ("overflow in enumeration values at `%D'", name);
13529             }
13530           else
13531             value = integer_zero_node;
13532         }
13533
13534       /* Remove no-op casts from the value.  */
13535       if (value)
13536         STRIP_TYPE_NOPS (value);
13537 #if 0
13538       /* To fix MAX_VAL enum consts. (bkoz)  */
13539       TREE_TYPE (value) = integer_type_node;
13540 #endif
13541     }
13542
13543   /* We always have to copy here; not all INTEGER_CSTs are unshared.
13544      Even in other cases, we will later (in finish_enum) be setting
13545      the type of VALUE.  But, we don't need to make a copy if this
13546      VALUE is one of the enumeration constants for this same
13547      enumeration type.  */
13548   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
13549     if (TREE_VALUE (values) == value)
13550       break;
13551   /* If we didn't break out of the loop, then we do need a copy.  */
13552   if (!values && value)
13553     value = copy_node (value);
13554
13555   /* C++ associates enums with global, function, or class declarations.  */
13556   context = current_scope ();
13557
13558   /* Build the actual enumeration constant.  Note that the enumeration
13559     constants have the type of their initializers until the
13560     enumeration is complete:
13561
13562       [ dcl.enum ]
13563
13564       Following the closing brace of an enum-specifier, each enumer-
13565       ator has the type of its enumeration.  Prior to the closing
13566       brace, the type of each enumerator is the type of its
13567       initializing value.
13568
13569     In finish_enum we will reset the type.  Of course, if we're
13570     processing a template, there may be no value.   */
13571   type = value ? TREE_TYPE (value) : NULL_TREE;
13572
13573   if (context && context == current_class_type)
13574     /* This enum declaration is local to the class.  We need the full
13575       lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
13576     decl = build_lang_decl (CONST_DECL, name, type);
13577   else
13578     /* It's a global enum, or it's local to a function.  (Note local to
13579       a function could mean local to a class method.  */
13580     decl = build_decl (CONST_DECL, name, type);
13581
13582   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
13583   DECL_INITIAL (decl) = value;
13584   TREE_READONLY (decl) = 1;
13585
13586   if (context && context == current_class_type)
13587     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13588       on the TYPE_FIELDS list for `S'.  (That's so that you can say
13589       things like `S::i' later.)  */
13590     finish_member_declaration (decl);
13591   else
13592     {
13593       pushdecl (decl);
13594       GNU_xref_decl (current_function_decl, decl);
13595     }
13596
13597   /* Add this enumeration constant to the list for this type.  */
13598   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13599 }
13600
13601 \f
13602 /* We're defining DECL.  Make sure that it's type is OK.  */
13603
13604 static void
13605 check_function_type (decl)
13606      tree decl;
13607 {
13608   tree fntype = TREE_TYPE (decl);
13609   tree return_type = complete_type (TREE_TYPE (fntype));
13610
13611   /* In a function definition, arg types must be complete.  */
13612   require_complete_types_for_parms (current_function_parms);
13613
13614   if (!COMPLETE_OR_VOID_TYPE_P (return_type))
13615     {
13616       cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
13617
13618       /* Make it return void instead, but don't change the
13619          type of the DECL_RESULT, in case we have a named return value.  */
13620       if (TREE_CODE (fntype) == METHOD_TYPE)
13621         {
13622           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
13623           TREE_TYPE (decl)
13624             = build_cplus_method_type (ctype,
13625                                        void_type_node,
13626                                        FUNCTION_ARG_CHAIN (decl));
13627         }
13628       else
13629         TREE_TYPE (decl)
13630           = build_function_type (void_type_node,
13631                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
13632       TREE_TYPE (decl)
13633         = build_exception_variant (fntype,
13634                                    TYPE_RAISES_EXCEPTIONS (fntype));
13635     }
13636   else
13637     abstract_virtuals_error (decl, TREE_TYPE (fntype));
13638 }
13639
13640 /* Create the FUNCTION_DECL for a function definition.
13641    DECLSPECS and DECLARATOR are the parts of the declaration;
13642    they describe the function's name and the type it returns,
13643    but twisted together in a fashion that parallels the syntax of C.
13644
13645    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13646    DECLARATOR is really the DECL for the function we are about to
13647    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13648    indicating that the function is an inline defined in-class, and
13649    SF_EXPAND indicating that we should generate RTL for this
13650    function.
13651
13652    This function creates a binding context for the function body
13653    as well as setting up the FUNCTION_DECL in current_function_decl.
13654
13655    Returns 1 on success.  If the DECLARATOR is not suitable for a function
13656    (it defines a datum instead), we return 0, which tells
13657    yyparse to report a parse error.
13658
13659    For C++, we must first check whether that datum makes any sense.
13660    For example, "class A local_a(1,2);" means that variable local_a
13661    is an aggregate of type A, which should have a constructor
13662    applied to it with the argument list [1, 2].  */
13663
13664 int
13665 start_function (declspecs, declarator, attrs, flags)
13666      tree declspecs, declarator, attrs;
13667      int flags;
13668 {
13669   tree decl1;
13670   tree ctype = NULL_TREE;
13671   tree fntype;
13672   tree restype;
13673   extern int have_extern_spec;
13674   extern int used_extern_spec;
13675   int doing_friend = 0;
13676   struct binding_level *bl;
13677
13678   /* Sanity check.  */
13679   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
13680   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
13681
13682   /* This should only be done once on the top most decl.  */
13683   if (have_extern_spec && !used_extern_spec)
13684     {
13685       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
13686       used_extern_spec = 1;
13687     }
13688
13689   if (flags & SF_PRE_PARSED)
13690     {
13691       decl1 = declarator;
13692
13693       fntype = TREE_TYPE (decl1);
13694       if (TREE_CODE (fntype) == METHOD_TYPE)
13695         ctype = TYPE_METHOD_BASETYPE (fntype);
13696
13697       /* ISO C++ 11.4/5.  A friend function defined in a class is in
13698          the (lexical) scope of the class in which it is defined.  */
13699       if (!ctype && DECL_FRIEND_P (decl1))
13700         {
13701           ctype = DECL_FRIEND_CONTEXT (decl1);
13702
13703           /* CTYPE could be null here if we're dealing with a template;
13704              for example, `inline friend float foo()' inside a template
13705              will have no CTYPE set.  */
13706           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13707             ctype = NULL_TREE;
13708           else
13709             doing_friend = 1;
13710         }
13711
13712       last_function_parms = DECL_ARGUMENTS (decl1);
13713       last_function_parm_tags = NULL_TREE;
13714     }
13715   else
13716     {
13717       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL_TREE);
13718       /* If the declarator is not suitable for a function definition,
13719          cause a syntax error.  */
13720       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
13721
13722       fntype = TREE_TYPE (decl1);
13723
13724       restype = TREE_TYPE (fntype);
13725       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13726         {
13727           cp_error ("semicolon missing after declaration of `%#T'", restype);
13728           shadow_tag (build_tree_list (NULL_TREE, restype));
13729           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13730           if (TREE_CODE (fntype) == FUNCTION_TYPE)
13731             fntype = build_function_type (integer_type_node,
13732                                           TYPE_ARG_TYPES (fntype));
13733           else
13734             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13735                                               integer_type_node,
13736                                               TYPE_ARG_TYPES (fntype));
13737           TREE_TYPE (decl1) = fntype;
13738         }
13739
13740       if (TREE_CODE (fntype) == METHOD_TYPE)
13741         ctype = TYPE_METHOD_BASETYPE (fntype);
13742       else if (DECL_MAIN_P (decl1))
13743         {
13744           /* If this doesn't return integer_type, complain.  */
13745           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13746             {
13747               if (pedantic || warn_return_type)
13748                 pedwarn ("return type for `main' changed to `int'");
13749               TREE_TYPE (decl1) = fntype = default_function_type;
13750             }
13751         }
13752     }
13753
13754   /* Sometimes we don't notice that a function is a static member, and
13755      build a METHOD_TYPE for it.  Fix that up now.  */
13756   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13757       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13758     {
13759       revert_static_member_fn (decl1);
13760       last_function_parms = TREE_CHAIN (last_function_parms);
13761       ctype = NULL_TREE;
13762     }
13763
13764   /* Warn if function was previously implicitly declared
13765      (but not if we warned then).  */
13766   if (! warn_implicit
13767       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13768     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13769
13770   /* Set up current_class_type, and enter the scope of the class, if
13771      appropriate.  */
13772   if (ctype)
13773     push_nested_class (ctype, 1);
13774   else if (DECL_STATIC_FUNCTION_P (decl1))
13775     push_nested_class (DECL_CONTEXT (decl1), 2);
13776
13777   /* Now that we have entered the scope of the class, we must restore
13778      the bindings for any template parameters surrounding DECL1, if it
13779      is an inline member template.  (Order is important; consider the
13780      case where a template parameter has the same name as a field of
13781      the class.)  It is not until after this point that
13782      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
13783   if (flags & SF_INCLASS_INLINE)
13784     maybe_begin_member_template_processing (decl1);
13785
13786   /* Effective C++ rule 15.  */
13787   if (warn_ecpp
13788       && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
13789       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13790     cp_warning ("`operator=' should return a reference to `*this'");
13791
13792   /* Make the init_value nonzero so pushdecl knows this is not tentative.
13793      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
13794   if (!DECL_INITIAL (decl1))
13795     DECL_INITIAL (decl1) = error_mark_node;
13796
13797 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
13798   SET_DEFAULT_DECL_ATTRIBUTES (decl1, attrs);
13799 #endif
13800
13801   /* This function exists in static storage.
13802      (This does not mean `static' in the C sense!)  */
13803   TREE_STATIC (decl1) = 1;
13804
13805   /* We must call push_template_decl after current_class_type is set
13806      up.  (If we are processing inline definitions after exiting a
13807      class scope, current_class_type will be NULL_TREE until set above
13808      by push_nested_class.)  */
13809   if (processing_template_decl)
13810     decl1 = push_template_decl (decl1);
13811
13812   /* We are now in the scope of the function being defined.  */
13813   current_function_decl = decl1;
13814
13815   /* Save the parm names or decls from this function's declarator
13816      where store_parm_decls will find them.  */
13817   current_function_parms = last_function_parms;
13818   current_function_parm_tags = last_function_parm_tags;
13819
13820   /* Make sure the parameter and return types are reasonable.  When
13821      you declare a function, these types can be incomplete, but they
13822      must be complete when you define the function.  */
13823   if (! processing_template_decl)
13824     check_function_type (decl1);
13825
13826   /* Build the return declaration for the function.  */
13827   restype = TREE_TYPE (fntype);
13828   if (!processing_template_decl)
13829     {
13830       if (!DECL_RESULT (decl1))
13831         {
13832           DECL_RESULT (decl1)
13833             = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13834           c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype),
13835                                       DECL_RESULT (decl1));
13836         }
13837     }
13838   else
13839     /* Just use `void'.  Nobody will ever look at this anyhow.  */
13840     DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, void_type_node);
13841
13842   /* Initialize RTL machinery.  We cannot do this until
13843      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
13844      even when processing a template; this is how we get
13845      CFUN set up, and our per-function variables initialized.  */
13846   bl = current_binding_level;
13847   init_function_start (decl1, input_filename, lineno);
13848   current_binding_level = bl;
13849   expanding_p = (flags & SF_EXPAND) != 0;
13850
13851   /* Even though we're inside a function body, we still don't want to
13852      call expand_expr to calculate the size of a variable-sized array.
13853      We haven't necessarily assigned RTL to all variables yet, so it's
13854      not safe to try to expand expressions involving them.  */
13855   immediate_size_expand = 0;
13856   cfun->x_dont_save_pending_sizes_p = 1;
13857
13858   /* If we're building a statement-tree, start the tree now.  */
13859   if (processing_template_decl || !expanding_p)
13860     begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13861
13862   /* Let the user know we're compiling this function.  */
13863   announce_function (decl1);
13864
13865   /* Record the decl so that the function name is defined.
13866      If we already have a decl for this name, and it is a FUNCTION_DECL,
13867      use the old decl.  */
13868   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13869     {
13870       /* A specialization is not used to guide overload resolution.  */
13871       if (!DECL_TEMPLATE_SPECIALIZATION (decl1)
13872           && ! DECL_FUNCTION_MEMBER_P (decl1))
13873         decl1 = pushdecl (decl1);
13874       else
13875         {
13876           /* We need to set the DECL_CONTEXT. */
13877           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13878             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13879           /* And make sure we have enough default args.  */
13880           check_default_args (decl1);
13881         }
13882       fntype = TREE_TYPE (decl1);
13883     }
13884
13885   /* Reset these in case the call to pushdecl changed them.  */
13886   current_function_decl = decl1;
13887   cfun->decl = decl1;
13888
13889   /* Initialize the per-function data.  */
13890   if (!DECL_PENDING_INLINE_P (decl1) && DECL_SAVED_FUNCTION_DATA (decl1))
13891     {
13892       /* If we already parsed this function, and we're just expanding it
13893          now, restore saved state.  */
13894       struct binding_level *bl = current_binding_level;
13895       *cp_function_chain = *DECL_SAVED_FUNCTION_DATA (decl1);
13896       current_binding_level = bl;
13897
13898       /* This function is being processed in whole-function mode; we
13899          already did semantic analysis.  */
13900       cfun->x_whole_function_mode_p = 1;
13901
13902       /* If we decided that we didn't want to inline this function,
13903          make sure the back-end knows that.  */
13904       if (!current_function_cannot_inline)
13905         current_function_cannot_inline = cp_function_chain->cannot_inline;
13906
13907       /* We don't need the saved data anymore.  */
13908       free (DECL_SAVED_FUNCTION_DATA (decl1));
13909       DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13910     }
13911   else if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13912     {
13913       /* We know that this was set up by `grokclassfn'.  We do not
13914          wait until `store_parm_decls', since evil parse errors may
13915          never get us to that point.  Here we keep the consistency
13916          between `current_class_type' and `current_class_ptr'.  */
13917       tree t = DECL_ARGUMENTS (decl1);
13918
13919       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13920                           162);
13921       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13922                           19990811);
13923
13924       cp_function_chain->x_current_class_ref
13925         = build_indirect_ref (t, NULL_PTR);
13926       cp_function_chain->x_current_class_ptr = t;
13927
13928       /* Constructors and destructors need to know whether they're "in
13929          charge" of initializing virtual base classes.  */
13930       if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
13931         current_in_charge_parm = TREE_CHAIN (t);
13932     }
13933
13934   if (DECL_INTERFACE_KNOWN (decl1))
13935     {
13936       tree ctx = decl_function_context (decl1);
13937
13938       if (DECL_NOT_REALLY_EXTERN (decl1))
13939         DECL_EXTERNAL (decl1) = 0;
13940
13941       if (ctx != NULL_TREE && DECL_THIS_INLINE (ctx)
13942           && TREE_PUBLIC (ctx))
13943         /* This is a function in a local class in an extern inline
13944            function.  */
13945         comdat_linkage (decl1);
13946     }
13947   /* If this function belongs to an interface, it is public.
13948      If it belongs to someone else's interface, it is also external.
13949      This only affects inlines and template instantiations.  */
13950   else if (interface_unknown == 0
13951            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13952                || flag_alt_external_templates))
13953     {
13954       if (DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1)
13955           || processing_template_decl)
13956         {
13957           DECL_EXTERNAL (decl1)
13958             = (interface_only
13959                || (DECL_THIS_INLINE (decl1) && ! flag_implement_inlines
13960                    && !DECL_VINDEX (decl1)));
13961
13962           /* For WIN32 we also want to put these in linkonce sections.  */
13963           maybe_make_one_only (decl1);
13964         }
13965       else
13966         DECL_EXTERNAL (decl1) = 0;
13967       DECL_NOT_REALLY_EXTERN (decl1) = 0;
13968       DECL_INTERFACE_KNOWN (decl1) = 1;
13969     }
13970   else if (interface_unknown && interface_only
13971            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13972                || flag_alt_external_templates))
13973     {
13974       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13975          interface, we will have interface_only set but not
13976          interface_known.  In that case, we don't want to use the normal
13977          heuristics because someone will supply a #pragma implementation
13978          elsewhere, and deducing it here would produce a conflict.  */
13979       comdat_linkage (decl1);
13980       DECL_EXTERNAL (decl1) = 0;
13981       DECL_INTERFACE_KNOWN (decl1) = 1;
13982       DECL_DEFER_OUTPUT (decl1) = 1;
13983     }
13984   else
13985     {
13986       /* This is a definition, not a reference.
13987          So clear DECL_EXTERNAL.  */
13988       DECL_EXTERNAL (decl1) = 0;
13989
13990       if ((DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1))
13991           && ! DECL_INTERFACE_KNOWN (decl1)
13992           /* Don't try to defer nested functions for now.  */
13993           && ! decl_function_context (decl1))
13994         DECL_DEFER_OUTPUT (decl1) = 1;
13995       else
13996         DECL_INTERFACE_KNOWN (decl1) = 1;
13997     }
13998
13999   if (doing_semantic_analysis_p ())
14000     {
14001       pushlevel (0);
14002       current_binding_level->parm_flag = 1;
14003     }
14004
14005   if (attrs)
14006     cplus_decl_attributes (decl1, NULL_TREE, attrs);
14007
14008   if (!building_stmt_tree ())
14009     GNU_xref_function (decl1, current_function_parms);
14010
14011   /* We need to do this even if we aren't expanding yet so that
14012      assemble_external works.  */
14013   make_function_rtl (decl1);
14014
14015   /* Promote the value to int before returning it.  */
14016   if (C_PROMOTING_INTEGER_TYPE_P (restype))
14017     restype = type_promotes_to (restype);
14018
14019   /* If this fcn was already referenced via a block-scope `extern' decl
14020      (or an implicit decl), propagate certain information about the usage.  */
14021   if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1)))
14022     TREE_ADDRESSABLE (decl1) = 1;
14023
14024   if (DECL_RESULT (decl1) == NULL_TREE)
14025     {
14026       DECL_RESULT (decl1)
14027         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
14028       TREE_READONLY (DECL_RESULT (decl1)) = CP_TYPE_CONST_P (restype);
14029       TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = CP_TYPE_VOLATILE_P (restype);
14030     }
14031
14032   ++function_depth;
14033
14034   if (DECL_DESTRUCTOR_P (decl1))
14035     {
14036       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
14037       DECL_CONTEXT (dtor_label) = current_function_decl;
14038     }
14039   /* Under the old ABI we return `this' from constructors, so we make
14040      ordinary `return' statements in constructors jump to CTOR_LABEL;
14041      from there we return `this'.  Under the new ABI, we don't bother
14042      with any of this.  By not setting CTOR_LABEL the remainder of the
14043      machinery is automatically disabled.  */
14044   else if (!flag_new_abi && DECL_CONSTRUCTOR_P (decl1))
14045     {
14046       ctor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
14047       DECL_CONTEXT (ctor_label) = current_function_decl;
14048     }
14049
14050   return 1;
14051 }
14052 \f
14053 /* Called after store_parm_decls for a function-try-block.  */
14054
14055 void
14056 expand_start_early_try_stmts ()
14057 {
14058   expand_start_try_stmts ();
14059 }
14060
14061 /* Store the parameter declarations into the current function declaration.
14062    This is called after parsing the parameter declarations, before
14063    digesting the body of the function.
14064
14065    Also install to binding contour return value identifier, if any.  */
14066
14067 void
14068 store_parm_decls ()
14069 {
14070   register tree fndecl = current_function_decl;
14071   register tree parm;
14072   int parms_have_cleanups = 0;
14073   tree cleanups = NULL_TREE;
14074
14075   /* This is a list of types declared among parms in a prototype.  */
14076   tree parmtags = current_function_parm_tags;
14077
14078   /* This is a chain of any other decls that came in among the parm
14079      declarations.  If a parm is declared with  enum {foo, bar} x;
14080      then CONST_DECLs for foo and bar are put here.  */
14081   tree nonparms = NULL_TREE;
14082
14083   /* Create a binding level for the parms.  */
14084   if (!building_stmt_tree ())
14085     expand_start_bindings (2);
14086
14087   if (current_function_parms)
14088     {
14089       /* This case is when the function was defined with an ANSI prototype.
14090          The parms already have decls, so we need not do anything here
14091          except record them as in effect
14092          and complain if any redundant old-style parm decls were written.  */
14093
14094       tree specparms = current_function_parms;
14095       tree next;
14096
14097       if (doing_semantic_analysis_p ())
14098         {
14099           /* Must clear this because it might contain TYPE_DECLs declared
14100              at class level.  */
14101           storedecls (NULL_TREE);
14102
14103           /* If we're doing semantic analysis, then we'll call pushdecl
14104              for each of these.  We must do them in reverse order so that
14105              they end in the correct forward order.  */
14106           specparms = nreverse (specparms);
14107         }
14108
14109       for (parm = specparms; parm; parm = next)
14110         {
14111           next = TREE_CHAIN (parm);
14112           if (TREE_CODE (parm) == PARM_DECL)
14113             {
14114               tree type = TREE_TYPE (parm);
14115
14116               if (doing_semantic_analysis_p ())
14117                 {
14118                   tree cleanup;
14119
14120                   if (DECL_NAME (parm) == NULL_TREE
14121                       || TREE_CODE (parm) != VOID_TYPE)
14122                     pushdecl (parm);
14123                   else
14124                     cp_error ("parameter `%D' declared void", parm);
14125
14126                   cleanup = (processing_template_decl
14127                              ? NULL_TREE
14128                              : maybe_build_cleanup (parm));
14129
14130                   if (cleanup)
14131                     cleanups = tree_cons (parm, cleanup, cleanups);
14132                 }
14133               else if (type != error_mark_node
14134                        && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14135                 parms_have_cleanups = 1;
14136             }
14137           else
14138             {
14139               /* If we find an enum constant or a type tag,
14140                  put it aside for the moment.  */
14141               TREE_CHAIN (parm) = NULL_TREE;
14142               nonparms = chainon (nonparms, parm);
14143             }
14144         }
14145
14146       if (doing_semantic_analysis_p ())
14147         {
14148           /* Get the decls in their original chain order
14149              and record in the function.  This is all and only the
14150              PARM_DECLs that were pushed into scope by the loop above.  */
14151           DECL_ARGUMENTS (fndecl) = getdecls ();
14152           storetags (chainon (parmtags, gettags ()));
14153         }
14154     }
14155   else
14156     DECL_ARGUMENTS (fndecl) = NULL_TREE;
14157
14158   /* Now store the final chain of decls for the arguments
14159      as the decl-chain of the current lexical scope.
14160      Put the enumerators in as well, at the front so that
14161      DECL_ARGUMENTS is not modified.  */
14162   if (doing_semantic_analysis_p ())
14163     storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
14164
14165   /* Initialize the RTL code for the function.  */
14166   DECL_SAVED_INSNS (fndecl) = 0;
14167   if (! building_stmt_tree ())
14168     expand_function_start (fndecl, parms_have_cleanups);
14169
14170   current_function_parms_stored = 1;
14171
14172   /* If this function is `main', emit a call to `__main'
14173      to run global initializers, etc.  */
14174   if (DECL_MAIN_P (fndecl) && !building_stmt_tree ())
14175     expand_main_function ();
14176
14177   /* Now that we have initialized the parms, we can start their
14178      cleanups.  We cannot do this before, since expand_decl_cleanup
14179      should not be called before the parm can be used.  */
14180   while (cleanups)
14181     {
14182       finish_decl_cleanup (TREE_PURPOSE (cleanups),
14183                            TREE_VALUE (cleanups));
14184       cleanups = TREE_CHAIN (cleanups);
14185     }
14186
14187   /* Create a binding contour which can be used to catch
14188      cleanup-generated temporaries.  Also, if the return value needs or
14189      has initialization, deal with that now.  */
14190   if (parms_have_cleanups)
14191     {
14192       pushlevel (0);
14193       if (!building_stmt_tree ())
14194         expand_start_bindings (2);
14195     }
14196
14197   /* Do the starting of the exception specifications, if we have any.  */
14198   if (flag_exceptions && !processing_template_decl
14199       && flag_enforce_eh_specs
14200       && building_stmt_tree ()
14201       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14202     current_eh_spec_try_block = expand_start_eh_spec ();
14203 }
14204
14205 \f
14206 /* We have finished doing semantic analysis on DECL, but have not yet
14207    generated RTL for its body.  Save away our current state, so that
14208    when we want to generate RTL later we know what to do.  */
14209
14210 static void
14211 save_function_data (decl)
14212      tree decl;
14213 {
14214   struct cp_language_function *f;
14215
14216   /* Save the language-specific per-function data so that we can
14217      get it back when we really expand this function.  */
14218   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
14219                       19990908);
14220
14221   /* Make a copy.  */
14222   f = ((struct cp_language_function *)
14223        xmalloc (sizeof (struct cp_language_function)));
14224   bcopy ((char *) cp_function_chain, (char *) f,
14225          sizeof (struct cp_language_function));
14226   DECL_SAVED_FUNCTION_DATA (decl) = f;
14227
14228   /* Clear out the bits we don't need.  */
14229   f->base.x_stmt_tree.x_last_stmt = NULL_TREE;
14230   f->base.x_stmt_tree.x_last_expr_type = NULL_TREE;
14231   f->x_result_rtx = NULL_RTX;
14232   f->x_named_label_uses = NULL;
14233   f->bindings = NULL;
14234
14235   /* When we get back here again, we will be expanding.  */
14236   f->x_expanding_p = 1;
14237
14238   /* If we've already decided that we cannot inline this function, we
14239      must remember that fact when we actually go to expand the
14240      function.  */
14241   f->cannot_inline = current_function_cannot_inline;
14242 }
14243
14244 /* At the end of every constructor we generate to code to return
14245    `this'.  Do that now.  */
14246
14247 static void
14248 finish_constructor_body ()
14249 {
14250   /* Any return from a constructor will end up here.  */
14251   if (ctor_label)
14252     add_stmt (build_stmt (LABEL_STMT, ctor_label));
14253
14254   /* Clear CTOR_LABEL so that finish_return_stmt knows to really
14255      generate the return, rather than a goto to CTOR_LABEL.  */
14256   ctor_label = NULL_TREE;
14257   /* In check_return_expr we translate an empty return from a
14258      constructor to a return of `this'.  */
14259   finish_return_stmt (NULL_TREE);
14260   /* Mark the end of the constructor.  */
14261   add_stmt (build_stmt (CTOR_STMT));
14262 }
14263
14264 /* At the end of every destructor we generate code to restore virtual
14265    function tables to the values desired by base classes and to call
14266    to base class destructors.  Do that now.  */
14267
14268 static void
14269 finish_destructor_body ()
14270 {
14271   tree compound_stmt;
14272   tree virtual_size;
14273   tree exprstmt;
14274   tree if_stmt;
14275
14276   /* Create a block to contain all the extra code.  */
14277   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
14278
14279   /* Any return from a destructor will end up here.  */
14280   add_stmt (build_stmt (LABEL_STMT, dtor_label));
14281
14282   /* Generate the code to call destructor on base class.  If this
14283      destructor belongs to a class with virtual functions, then set
14284      the virtual function table pointer to represent the type of our
14285      base class.  */
14286
14287   /* This side-effect makes call to `build_delete' generate the code
14288      we have to have at the end of this destructor.  `build_delete'
14289      will set the flag again.  */
14290   TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
14291
14292   exprstmt = build_delete (current_class_type,
14293                            current_class_ref,
14294                            sfk_base_destructor,
14295                            LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
14296                            0);
14297
14298   if (exprstmt != error_mark_node
14299       && (TREE_CODE (exprstmt) != NOP_EXPR
14300           || TREE_OPERAND (exprstmt, 0) != integer_zero_node
14301           || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
14302     {
14303       if (exprstmt != void_zero_node)
14304         /* Don't call `expand_expr_stmt' if we're not going to do
14305            anything, since -Wall will give a diagnostic.  */
14306         finish_expr_stmt (exprstmt);
14307
14308       /* Run destructors for all virtual baseclasses.  */
14309       if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
14310         {
14311           tree vbases;
14312           tree if_stmt;
14313
14314           if_stmt = begin_if_stmt ();
14315           finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
14316                                       current_in_charge_parm,
14317                                       integer_two_node),
14318                                if_stmt);
14319
14320           vbases = CLASSTYPE_VBASECLASSES (current_class_type);
14321           /* The CLASSTYPE_VBASECLASSES list is in initialization
14322              order, so we have to march through it in reverse order.  */
14323           for (vbases = nreverse (copy_list (vbases));
14324                vbases;
14325                vbases = TREE_CHAIN (vbases))
14326             {
14327               tree vbase = TREE_VALUE (vbases);
14328
14329               if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (vbase)))
14330                 {
14331                   tree vb = get_vbase
14332                     (BINFO_TYPE (vbase),
14333                      TYPE_BINFO (current_class_type));
14334                   finish_expr_stmt
14335                     (build_scoped_method_call
14336                      (current_class_ref, vb, base_dtor_identifier,
14337                       NULL_TREE));
14338                 }
14339             }
14340
14341           finish_then_clause (if_stmt);
14342           finish_if_stmt ();
14343         }
14344     }
14345
14346   virtual_size = c_sizeof (current_class_type);
14347
14348   /* At the end, call delete if that's what's requested.  */
14349
14350   /* FDIS sez: At the point of definition of a virtual destructor
14351      (including an implicit definition), non-placement operator delete
14352      shall be looked up in the scope of the destructor's class and if
14353      found shall be accessible and unambiguous.
14354
14355      This is somewhat unclear, but I take it to mean that if the class
14356      only defines placement deletes we don't do anything here.  So we
14357      pass LOOKUP_SPECULATIVELY; delete_sanity will complain for us if
14358      they ever try to delete one of these.  */
14359   exprstmt = build_op_delete_call
14360     (DELETE_EXPR, current_class_ptr, virtual_size,
14361      LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
14362
14363   if_stmt = begin_if_stmt ();
14364   finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
14365                               current_in_charge_parm,
14366                               integer_one_node),
14367                        if_stmt);
14368   finish_expr_stmt (exprstmt);
14369   finish_then_clause (if_stmt);
14370   finish_if_stmt ();
14371
14372   /* Close the block we started above.  */
14373   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
14374 }
14375
14376 /* Finish up a function declaration and compile that function
14377    all the way to assembler language output.  The free the storage
14378    for the function definition.
14379
14380    FLAGS is a bitwise or of the following values:
14381      1 - CALL_POPLEVEL
14382        An extra call to poplevel (and expand_end_bindings) must be
14383        made to take care of the binding contour for the base
14384        initializers.  This is only relevant for constructors.
14385      2 - INCLASS_INLINE
14386        We just finished processing the body of an in-class inline
14387        function definition.  (This processing will have taken place
14388        after the class definition is complete.)  */
14389
14390 tree
14391 finish_function (flags)
14392      int flags;
14393 {
14394   register tree fndecl = current_function_decl;
14395   tree fntype, ctype = NULL_TREE;
14396   /* Label to use if this function is supposed to return a value.  */
14397   tree no_return_label = NULL_TREE;
14398   int call_poplevel = (flags & 1) != 0;
14399   int inclass_inline = (flags & 2) != 0;
14400   int expand_p;
14401   int nested;
14402   int current_line = lineno;
14403
14404   /* When we get some parse errors, we can end up without a
14405      current_function_decl, so cope.  */
14406   if (fndecl == NULL_TREE)
14407     return error_mark_node;
14408
14409   nested = function_depth > 1;
14410   fntype = TREE_TYPE (fndecl);
14411
14412   /*  TREE_READONLY (fndecl) = 1;
14413       This caused &foo to be of type ptr-to-const-function
14414       which then got a warning when stored in a ptr-to-function variable.  */
14415
14416   /* This happens on strange parse errors.  */
14417   if (! current_function_parms_stored)
14418     {
14419       call_poplevel = 0;
14420       store_parm_decls ();
14421     }
14422
14423   /* For a cloned function, we've already got all the code we need;
14424      there's no need to add any extra bits.  */
14425   if (building_stmt_tree () && DECL_CLONED_FUNCTION_P (fndecl))
14426     ;
14427   else if (building_stmt_tree ())
14428     {
14429       if (DECL_CONSTRUCTOR_P (fndecl))
14430         {
14431           finish_constructor_body ();
14432           if (call_poplevel)
14433             do_poplevel ();
14434         }
14435       else if (DECL_DESTRUCTOR_P (fndecl) && !processing_template_decl)
14436         finish_destructor_body ();
14437       else if (DECL_MAIN_P (fndecl))
14438         {
14439           /* Make it so that `main' always returns 0 by default.  */
14440 #ifdef VMS
14441           finish_return_stmt (integer_one_node);
14442 #else
14443           finish_return_stmt (integer_zero_node);
14444 #endif
14445         }
14446
14447       /* Finish dealing with exception specifiers.  */
14448       if (flag_exceptions && !processing_template_decl
14449           && flag_enforce_eh_specs
14450           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14451         expand_end_eh_spec (TYPE_RAISES_EXCEPTIONS
14452                             (TREE_TYPE (current_function_decl)),
14453                             current_eh_spec_try_block);
14454     }
14455   else
14456     {
14457 #if 0
14458       if (write_symbols != NO_DEBUG /*&& TREE_CODE (fntype) != METHOD_TYPE*/)
14459         {
14460           /* Keep this code around in case we later want to control debug info
14461              based on whether a type is "used".  (jason 1999-11-11) */
14462
14463           tree ttype = target_type (fntype);
14464           tree parmdecl;
14465
14466           if (IS_AGGR_TYPE (ttype))
14467             /* Let debugger know it should output info for this type.  */
14468             note_debug_info_needed (ttype);
14469
14470           for (parmdecl = DECL_ARGUMENTS (fndecl); parmdecl; parmdecl = TREE_CHAIN (parmdecl))
14471             {
14472               ttype = target_type (TREE_TYPE (parmdecl));
14473               if (IS_AGGR_TYPE (ttype))
14474                 /* Let debugger know it should output info for this type.  */
14475                 note_debug_info_needed (ttype);
14476             }
14477         }
14478 #endif
14479
14480       /* Clean house because we will need to reorder insns here.  */
14481       do_pending_stack_adjust ();
14482
14483       if (dtor_label)
14484         ;
14485       else if (DECL_CONSTRUCTOR_P (fndecl))
14486         {
14487           if (call_poplevel)
14488             do_poplevel ();
14489         }
14490       else if (return_label != NULL_RTX
14491                && flag_this_is_variable <= 0
14492                && current_function_return_value == NULL_TREE
14493                && ! DECL_NAME (DECL_RESULT (current_function_decl)))
14494         no_return_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
14495
14496       if (flag_exceptions)
14497         expand_exception_blocks ();
14498
14499       /* If this function is supposed to return a value, ensure that
14500          we do not fall into the cleanups by mistake.  The end of our
14501          function will look like this:
14502
14503          user code (may have return stmt somewhere)
14504          goto no_return_label
14505          cleanup_label:
14506          cleanups
14507          goto return_label
14508          no_return_label:
14509          NOTE_INSN_FUNCTION_END
14510          return_label:
14511          things for return
14512
14513          If the user omits a return stmt in the USER CODE section, we
14514          will have a control path which reaches NOTE_INSN_FUNCTION_END.
14515          Otherwise, we won't.  */
14516       if (no_return_label)
14517         {
14518           DECL_CONTEXT (no_return_label) = fndecl;
14519           DECL_INITIAL (no_return_label) = error_mark_node;
14520           DECL_SOURCE_FILE (no_return_label) = input_filename;
14521           DECL_SOURCE_LINE (no_return_label) = current_line;
14522           expand_goto (no_return_label);
14523         }
14524
14525       if (cleanup_label)
14526         {
14527           /* Remove the binding contour which is used
14528              to catch cleanup-generated temporaries.  */
14529           expand_end_bindings (0, 0, 0);
14530           poplevel (0, 0, 0);
14531
14532           /* Emit label at beginning of cleanup code for parameters.  */
14533           emit_label (cleanup_label);
14534         }
14535
14536       /* Get return value into register if that's where it's supposed
14537          to be.  */
14538       if (original_result_rtx)
14539         fixup_result_decl (DECL_RESULT (fndecl), original_result_rtx);
14540
14541       /* Finish building code that will trigger warnings if users forget
14542          to make their functions return values.  */
14543       if (no_return_label || cleanup_label)
14544         emit_jump (return_label);
14545       if (no_return_label)
14546         {
14547           /* We don't need to call `expand_*_return' here because we
14548              don't need any cleanups here--this path of code is only
14549              for error checking purposes.  */
14550           expand_label (no_return_label);
14551         }
14552
14553       /* We hard-wired immediate_size_expand to zero in
14554          start_function.  Expand_function_end will decrement this
14555          variable.  So, we set the variable to one here, so that after
14556          the decrement it will remain zero.  */
14557       immediate_size_expand = 1;
14558
14559       /* Generate rtl for function exit.  */
14560       expand_function_end (input_filename, current_line, 1);
14561     }
14562
14563   /* We have to save this value here in case
14564      maybe_end_member_template_processing decides to pop all the
14565      template parameters.  */
14566   expand_p = !building_stmt_tree ();
14567
14568   /* If we're saving up tree structure, tie off the function now.  */
14569   if (!expand_p)
14570     finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
14571
14572   /* This must come after expand_function_end because cleanups might
14573      have declarations (from inline functions) that need to go into
14574      this function's blocks.  */
14575   if (doing_semantic_analysis_p ())
14576     {
14577       if (current_binding_level->parm_flag != 1)
14578         my_friendly_abort (122);
14579       poplevel (1, 0, 1);
14580     }
14581
14582   /* Remember that we were in class scope.  */
14583   if (current_class_name)
14584     ctype = current_class_type;
14585
14586   /* Must mark the RESULT_DECL as being in this function.  */
14587   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
14588
14589   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14590      to the FUNCTION_DECL node itself.  */
14591   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
14592
14593   /* Save away current state, if appropriate.  */
14594   if (!expanding_p && !processing_template_decl)
14595     save_function_data (fndecl);
14596
14597   /* If this function calls `setjmp' it cannot be inlined.  When
14598      `longjmp' is called it is not guaranteed to restore the value of
14599      local variables that have been modified since the call to
14600      `setjmp'.  So, if were to inline this function into some caller
14601      `c', then when we `longjmp', we might not restore all variables
14602      in `c'.  (It might seem, at first blush, that there's no way for
14603      this function to modify local variables in `c', but their
14604      addresses may have been stored somewhere accessible to this
14605      function.)  */
14606   if (!expanding_p && !processing_template_decl && calls_setjmp_p (fndecl))
14607     DECL_UNINLINABLE (fndecl) = 1;
14608
14609   if (expand_p)
14610     {
14611       int returns_null;
14612       int returns_value;
14613
14614       /* So we can tell if jump_optimize sets it to 1.  */
14615       can_reach_end = 0;
14616
14617       /* Before we call rest_of_compilation (which will pop the
14618          CURRENT_FUNCTION), we must save these values.  */
14619       returns_null = current_function_returns_null;
14620       returns_value = current_function_returns_value;
14621
14622       /* If this is a nested function (like a template instantiation
14623          that we're compiling in the midst of compiling something
14624          else), push a new GC context.  That will keep local variables
14625          on the stack from being collected while we're doing the
14626          compilation of this function.  */
14627       if (function_depth > 1)
14628         ggc_push_context ();
14629
14630       /* Run the optimizers and output the assembler code for this
14631          function.  */
14632       rest_of_compilation (fndecl);
14633
14634       /* Undo the call to ggc_push_context above.  */
14635       if (function_depth > 1)
14636         ggc_pop_context ();
14637
14638       if (DECL_SAVED_INSNS (fndecl) && ! TREE_ASM_WRITTEN (fndecl))
14639         {
14640           /* Set DECL_EXTERNAL so that assemble_external will be called as
14641              necessary.  We'll clear it again in finish_file.  */
14642           if (! DECL_EXTERNAL (fndecl))
14643             DECL_NOT_REALLY_EXTERN (fndecl) = 1;
14644           DECL_EXTERNAL (fndecl) = 1;
14645           defer_fn (fndecl);
14646         }
14647
14648 #if 0
14649       /* Keep this code around in case we later want to control debug info
14650          based on whether a type is "used".  (jason 1999-11-11) */
14651
14652       if (ctype && TREE_ASM_WRITTEN (fndecl))
14653         note_debug_info_needed (ctype);
14654 #endif
14655
14656       /* If this function is marked with the constructor attribute,
14657          add it to the list of functions to be called along with
14658          constructors from static duration objects.  */
14659       if (DECL_STATIC_CONSTRUCTOR (fndecl))
14660         static_ctors = tree_cons (NULL_TREE, fndecl, static_ctors);
14661
14662       /* If this function is marked with the destructor attribute,
14663          add it to the list of functions to be called along with
14664          destructors from static duration objects.  */
14665       if (DECL_STATIC_DESTRUCTOR (fndecl))
14666         static_dtors = tree_cons (NULL_TREE, fndecl, static_dtors);
14667
14668       if (DECL_NAME (DECL_RESULT (fndecl)))
14669         returns_value |= can_reach_end;
14670       else
14671         returns_null |= can_reach_end;
14672
14673       if (TREE_THIS_VOLATILE (fndecl) && returns_null)
14674         warning ("`noreturn' function does return");
14675       else if (returns_null
14676                && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE)
14677         {
14678           /* Always complain if there's just no return statement.  */
14679           if (!returns_value)
14680             warning ("no return statement in function returning non-void");
14681           else if (warn_return_type || pedantic)
14682             /* If this function returns non-void and control can drop through,
14683                complain.  */
14684             warning ("control reaches end of non-void function");
14685         }
14686     }
14687   else
14688     {
14689       /* Clear out memory we no longer need.  */
14690       free_after_parsing (cfun);
14691       /* Since we never call rest_of_compilation, we never clear
14692          CFUN.  Do so explicitly.  */
14693       free_after_compilation (cfun);
14694       cfun = NULL;
14695     }
14696
14697   /* If this is a in-class inline definition, we may have to pop the
14698      bindings for the template parameters that we added in
14699      maybe_begin_member_template_processing when start_function was
14700      called.  */
14701   if (inclass_inline)
14702     maybe_end_member_template_processing ();
14703
14704   /* Leave the scope of the class.  */
14705   if (ctype)
14706     pop_nested_class ();
14707
14708   --function_depth;
14709
14710   if (!DECL_SAVED_INSNS (fndecl) && !DECL_SAVED_FUNCTION_DATA (fndecl)
14711       && !(flag_inline_trees && DECL_INLINE (fndecl)))
14712     {
14713       tree t;
14714
14715       /* Stop pointing to the local nodes about to be freed.  */
14716       /* But DECL_INITIAL must remain nonzero so we know this
14717          was an actual function definition.  */
14718       DECL_INITIAL (fndecl) = error_mark_node;
14719       for (t = DECL_ARGUMENTS (fndecl); t; t = TREE_CHAIN (t))
14720         DECL_RTL (t) = DECL_INCOMING_RTL (t) = NULL_RTX;
14721     }
14722
14723   /* Clean up.  */
14724   if (! nested)
14725     {
14726       /* Let the error reporting routines know that we're outside a
14727          function.  For a nested function, this value is used in
14728          pop_cp_function_context and then reset via pop_function_context.  */
14729       current_function_decl = NULL_TREE;
14730       /* We don't really care about obstacks, but the middle-end
14731          sometimes cares on what obstck things are located.  */
14732       permanent_allocation (1);
14733     }
14734
14735   return fndecl;
14736 }
14737 \f
14738 /* Create the FUNCTION_DECL for a function definition.
14739    DECLSPECS and DECLARATOR are the parts of the declaration;
14740    they describe the return type and the name of the function,
14741    but twisted together in a fashion that parallels the syntax of C.
14742
14743    This function creates a binding context for the function body
14744    as well as setting up the FUNCTION_DECL in current_function_decl.
14745
14746    Returns a FUNCTION_DECL on success.
14747
14748    If the DECLARATOR is not suitable for a function (it defines a datum
14749    instead), we return 0, which tells yyparse to report a parse error.
14750
14751    May return void_type_node indicating that this method is actually
14752    a friend.  See grokfield for more details.
14753
14754    Came here with a `.pushlevel' .
14755
14756    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14757    CHANGES TO CODE IN `grokfield'.  */
14758
14759 tree
14760 start_method (declspecs, declarator, attrlist)
14761      tree declarator, declspecs, attrlist;
14762 {
14763   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14764                                 attrlist);
14765
14766   /* Something too ugly to handle.  */
14767   if (fndecl == NULL_TREE)
14768     return NULL_TREE;
14769
14770   /* Pass friends other than inline friend functions back.  */
14771   if (fndecl == void_type_node)
14772     return fndecl;
14773
14774   if (TREE_CODE (fndecl) != FUNCTION_DECL)
14775     /* Not a function, tell parser to report parse error.  */
14776     return NULL_TREE;
14777
14778   if (DECL_IN_AGGR_P (fndecl))
14779     {
14780       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14781         {
14782           if (DECL_CONTEXT (fndecl)
14783               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14784             cp_error ("`%D' is already defined in class `%T'", fndecl,
14785                       DECL_CONTEXT (fndecl));
14786         }
14787       return void_type_node;
14788     }
14789
14790   check_template_shadow (fndecl);
14791
14792   DECL_THIS_INLINE (fndecl) = 1;
14793
14794   if (flag_default_inline)
14795     DECL_INLINE (fndecl) = 1;
14796
14797   /* We process method specializations in finish_struct_1.  */
14798   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14799     fndecl = push_template_decl (fndecl);
14800
14801   if (! DECL_FRIEND_P (fndecl))
14802     {
14803       if (TREE_CHAIN (fndecl))
14804         {
14805           fndecl = copy_node (fndecl);
14806           TREE_CHAIN (fndecl) = NULL_TREE;
14807         }
14808
14809       if (DECL_CONSTRUCTOR_P (fndecl))
14810         {
14811           if (! grok_ctor_properties (current_class_type, fndecl))
14812             return void_type_node;
14813         }
14814       else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl)))
14815         grok_op_properties (fndecl, DECL_VIRTUAL_P (fndecl), 0);
14816     }
14817
14818   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14819
14820   /* Make a place for the parms */
14821   pushlevel (0);
14822   current_binding_level->parm_flag = 1;
14823
14824   DECL_IN_AGGR_P (fndecl) = 1;
14825   return fndecl;
14826 }
14827
14828 /* Go through the motions of finishing a function definition.
14829    We don't compile this method until after the whole class has
14830    been processed.
14831
14832    FINISH_METHOD must return something that looks as though it
14833    came from GROKFIELD (since we are defining a method, after all).
14834
14835    This is called after parsing the body of the function definition.
14836    STMTS is the chain of statements that makes up the function body.
14837
14838    DECL is the ..._DECL that `start_method' provided.  */
14839
14840 tree
14841 finish_method (decl)
14842      tree decl;
14843 {
14844   register tree fndecl = decl;
14845   tree old_initial;
14846
14847   register tree link;
14848
14849   if (decl == void_type_node)
14850     return decl;
14851
14852   old_initial = DECL_INITIAL (fndecl);
14853
14854   /* Undo the level for the parms (from start_method).
14855      This is like poplevel, but it causes nothing to be
14856      saved.  Saving information here confuses symbol-table
14857      output routines.  Besides, this information will
14858      be correctly output when this method is actually
14859      compiled.  */
14860
14861   /* Clear out the meanings of the local variables of this level;
14862      also record in each decl which block it belongs to.  */
14863
14864   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14865     {
14866       if (DECL_NAME (link) != NULL_TREE)
14867         pop_binding (DECL_NAME (link), link);
14868       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14869       DECL_CONTEXT (link) = NULL_TREE;
14870     }
14871
14872   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
14873                       (HOST_WIDE_INT) current_binding_level->level_chain,
14874                       current_binding_level->parm_flag,
14875                       current_binding_level->keep);
14876
14877   poplevel (0, 0, 0);
14878
14879   DECL_INITIAL (fndecl) = old_initial;
14880
14881   /* We used to check if the context of FNDECL was different from
14882      current_class_type as another way to get inside here.  This didn't work
14883      for String.cc in libg++.  */
14884   if (DECL_FRIEND_P (fndecl))
14885     {
14886       CLASSTYPE_INLINE_FRIENDS (current_class_type)
14887         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14888       decl = void_type_node;
14889     }
14890
14891   return decl;
14892 }
14893 \f
14894 /* Called when a new struct TYPE is defined.
14895    If this structure or union completes the type of any previous
14896    variable declaration, lay it out and output its rtl.  */
14897
14898 void
14899 hack_incomplete_structures (type)
14900      tree type;
14901 {
14902   tree *list;
14903   struct binding_level *level;
14904
14905   if (!type) /* Don't do this for class templates.  */
14906     return;
14907
14908   if (namespace_bindings_p ())
14909     {
14910       level = 0;
14911       list = &namespace_scope_incomplete;
14912     }
14913   else
14914     {
14915       level = innermost_nonclass_level ();
14916       list = &level->incomplete;
14917     }
14918
14919   while (1)
14920     {
14921       while (*list)
14922         {
14923           tree decl = TREE_VALUE (*list);
14924           if ((decl && TREE_TYPE (decl) == type)
14925               || (TREE_TYPE (decl)
14926                   && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14927                   && TREE_TYPE (TREE_TYPE (decl)) == type))
14928             {
14929               int toplevel = toplevel_bindings_p ();
14930               if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14931                   && TREE_TYPE (TREE_TYPE (decl)) == type)
14932                 layout_type (TREE_TYPE (decl));
14933               layout_decl (decl, 0);
14934               rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
14935               if (! toplevel)
14936                 {
14937                   tree cleanup;
14938                   expand_decl (decl);
14939                   cleanup = maybe_build_cleanup (decl);
14940                   expand_decl_init (decl);
14941                   if (! expand_decl_cleanup (decl, cleanup))
14942                     cp_error ("parser lost in parsing declaration of `%D'",
14943                               decl);
14944                 }
14945               *list = TREE_CHAIN (*list);
14946             }
14947           else
14948             list = &TREE_CHAIN (*list);
14949         }
14950
14951       /* Keep looking through artificial binding levels generated
14952          for local variables.  */
14953       if (level && level->keep == 2)
14954         {
14955           level = level->level_chain;
14956           list = &level->incomplete;
14957         }
14958       else
14959         break;
14960     }
14961 }
14962
14963 /* If DECL is of a type which needs a cleanup, build that cleanup
14964    here.  */
14965
14966 tree
14967 maybe_build_cleanup (decl)
14968      tree decl;
14969 {
14970   tree type = TREE_TYPE (decl);
14971
14972   if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14973     {
14974       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14975       tree rval;
14976
14977       if (TREE_CODE (type) == ARRAY_TYPE)
14978         rval = decl;
14979       else
14980         {
14981           mark_addressable (decl);
14982           rval = build_unary_op (ADDR_EXPR, decl, 0);
14983         }
14984
14985       /* Optimize for space over speed here.  */
14986       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14987           || flag_expensive_optimizations)
14988         flags |= LOOKUP_NONVIRTUAL;
14989
14990       rval = build_delete (TREE_TYPE (rval), rval,
14991                            sfk_complete_destructor, flags, 0);
14992
14993       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14994           && ! TYPE_HAS_DESTRUCTOR (type))
14995         rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14996                                                build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14997
14998       return rval;
14999     }
15000   return 0;
15001 }
15002 \f
15003 /* Expand a C++ expression at the statement level.
15004    This is needed to ferret out nodes which have UNKNOWN_TYPE.
15005    The C++ type checker should get all of these out when
15006    expressions are combined with other, type-providing, expressions,
15007    leaving only orphan expressions, such as:
15008
15009    &class::bar;         / / takes its address, but does nothing with it.  */
15010
15011 void
15012 cplus_expand_expr_stmt (exp)
15013      tree exp;
15014 {
15015 #if 0
15016   /* We should do this eventually, but right now this causes regex.o from
15017      libg++ to miscompile, and tString to core dump.  */
15018   exp = build1 (CLEANUP_POINT_EXPR, TREE_TYPE (exp), exp);
15019 #endif
15020
15021   /* If we don't do this, we end up down inside expand_expr
15022      trying to do TYPE_MODE on the ERROR_MARK, and really
15023      go outside the bounds of the type.  */
15024   if (exp != error_mark_node)
15025     expand_expr_stmt (exp);
15026 }
15027
15028 /* When a stmt has been parsed, this function is called.  */
15029
15030 void
15031 finish_stmt ()
15032 {
15033   /* Always assume this statement was not an expression statement.  If
15034      it actually was an expression statement, its our callers
15035      responsibility to fix this up.  */
15036   last_expr_type = NULL_TREE;
15037 }
15038
15039 /* DECL was originally constructed as a non-static member function,
15040    but turned out to be static.  Update it accordingly.  */
15041
15042 void
15043 revert_static_member_fn (decl)
15044      tree decl;
15045 {
15046   tree tmp;
15047   tree function = TREE_TYPE (decl);
15048   tree args = TYPE_ARG_TYPES (function);
15049
15050   if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args)))
15051       != TYPE_UNQUALIFIED)
15052     cp_error ("static member function `%#D' declared with type qualifiers",
15053               *decl);
15054
15055   args = TREE_CHAIN (args);
15056   tmp = build_function_type (TREE_TYPE (function), args);
15057   tmp = build_qualified_type (tmp, CP_TYPE_QUALS (function));
15058   tmp = build_exception_variant (tmp,
15059                                  TYPE_RAISES_EXCEPTIONS (function));
15060   TREE_TYPE (decl) = tmp;
15061   if (DECL_ARGUMENTS (decl))
15062     DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
15063   DECL_STATIC_FUNCTION_P (decl) = 1;
15064 }
15065
15066 /* Initialize the variables used during compilation of a C++
15067    function.  */
15068
15069 static void
15070 push_cp_function_context (f)
15071      struct function *f;
15072 {
15073   struct cp_language_function *p
15074     = ((struct cp_language_function *)
15075        xcalloc (1, sizeof (struct cp_language_function)));
15076   f->language = (struct language_function *) p;
15077
15078   /* It takes an explicit call to expand_body to generate RTL for a
15079      function.  */
15080   expanding_p = 0;
15081
15082   /* Whenever we start a new function, we destroy temporaries in the
15083      usual way.  */
15084   current_stmt_tree ()->stmts_are_full_exprs_p = 1;
15085 }
15086
15087 /* Free the language-specific parts of F, now that we've finished
15088    compiling the function.  */
15089
15090 static void
15091 pop_cp_function_context (f)
15092      struct function *f;
15093 {
15094   if (f->language)
15095     free (f->language);
15096   f->language = 0;
15097 }
15098
15099 /* Mark P for GC.  */
15100
15101 static void
15102 mark_lang_function (p)
15103      struct cp_language_function *p;
15104 {
15105   if (!p)
15106     return;
15107
15108   ggc_mark_tree (p->x_ctor_label);
15109   ggc_mark_tree (p->x_dtor_label);
15110   ggc_mark_tree (p->x_current_class_ptr);
15111   ggc_mark_tree (p->x_current_class_ref);
15112   ggc_mark_tree (p->x_eh_spec_try_block);
15113   ggc_mark_tree (p->x_scope_stmt_stack);
15114
15115   ggc_mark_rtx (p->x_result_rtx);
15116
15117   mark_named_label_lists (&p->x_named_labels, &p->x_named_label_uses);
15118   mark_stmt_tree (&p->base.x_stmt_tree);
15119   mark_binding_level (&p->bindings);
15120 }
15121
15122 /* Mark the language-specific data in F for GC.  */
15123
15124 static void
15125 mark_cp_function_context (f)
15126      struct function *f;
15127 {
15128   mark_lang_function ((struct cp_language_function *) f->language);
15129 }
15130
15131 void
15132 lang_mark_false_label_stack (l)
15133      struct label_node *l;
15134 {
15135   /* C++ doesn't use false_label_stack.  It better be NULL.  */
15136   my_friendly_assert (l == NULL, 19990904);
15137 }
15138
15139 void
15140 lang_mark_tree (t)
15141      tree t;
15142 {
15143   enum tree_code code = TREE_CODE (t);
15144   if (code == IDENTIFIER_NODE)
15145     {
15146       struct lang_identifier *li = (struct lang_identifier *) t;
15147       struct lang_id2 *li2 = li->x;
15148       ggc_mark_tree (li->namespace_bindings);
15149       ggc_mark_tree (li->bindings);
15150       ggc_mark_tree (li->class_value);
15151       ggc_mark_tree (li->class_template_info);
15152
15153       if (li2)
15154         {
15155           ggc_mark_tree (li2->label_value);
15156           ggc_mark_tree (li2->implicit_decl);
15157           ggc_mark_tree (li2->error_locus);
15158         }
15159     }
15160   else if (code == CPLUS_BINDING)
15161     {
15162       if (BINDING_HAS_LEVEL_P (t))
15163         mark_binding_level (&BINDING_LEVEL (t));
15164       else
15165         ggc_mark_tree (BINDING_SCOPE (t));
15166       ggc_mark_tree (BINDING_VALUE (t));
15167     }
15168   else if (code == OVERLOAD)
15169     ggc_mark_tree (OVL_FUNCTION (t));
15170   else if (code == TEMPLATE_PARM_INDEX)
15171     ggc_mark_tree (TEMPLATE_PARM_DECL (t));
15172   else if (TREE_CODE_CLASS (code) == 'd')
15173     {
15174       struct lang_decl *ld = DECL_LANG_SPECIFIC (t);
15175
15176       if (ld)
15177         {
15178           ggc_mark (ld);
15179           if (!DECL_GLOBAL_CTOR_P (t)
15180               && !DECL_GLOBAL_DTOR_P (t)
15181               && !DECL_THUNK_P (t))
15182             ggc_mark_tree (ld->decl_flags.u2.access);
15183           else if (DECL_THUNK_P (t))
15184             ggc_mark_tree (ld->decl_flags.u2.vcall_offset);
15185           ggc_mark_tree (ld->decl_flags.context);
15186           if (TREE_CODE (t) != NAMESPACE_DECL)
15187             ggc_mark_tree (ld->decl_flags.u.template_info);
15188           else
15189             mark_binding_level (&NAMESPACE_LEVEL (t));
15190           if (CAN_HAVE_FULL_LANG_DECL_P (t))
15191             {
15192               ggc_mark_tree (ld->befriending_classes);
15193               ggc_mark_tree (ld->saved_tree);
15194               ggc_mark_tree (ld->cloned_function);
15195               if (!DECL_OVERLOADED_OPERATOR_P (t))
15196                 ggc_mark_tree (ld->u2.vtt_parm);
15197               if (TREE_CODE (t) == TYPE_DECL)
15198                 ggc_mark_tree (ld->u.sorted_fields);
15199               else if (TREE_CODE (t) == FUNCTION_DECL
15200                        && !DECL_PENDING_INLINE_P (t))
15201                 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t));
15202             }
15203         }
15204     }
15205   else if (TREE_CODE_CLASS (code) == 't')
15206     {
15207       struct lang_type *lt = TYPE_LANG_SPECIFIC (t);
15208
15209       if (lt && !(TREE_CODE (t) == POINTER_TYPE
15210                   && TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE))
15211         {
15212           ggc_mark (lt);
15213           ggc_mark_tree (lt->primary_base);
15214           ggc_mark_tree (lt->vfields);
15215           ggc_mark_tree (lt->vbases);
15216           ggc_mark_tree (lt->tags);
15217           ggc_mark_tree (lt->size);
15218           ggc_mark_tree (lt->pure_virtuals);
15219           ggc_mark_tree (lt->friend_classes);
15220           ggc_mark_tree (lt->rtti);
15221           ggc_mark_tree (lt->methods);
15222           ggc_mark_tree (lt->template_info);
15223           ggc_mark_tree (lt->befriending_classes);
15224         }
15225       else if (lt)
15226         /* In the case of pointer-to-member function types, the
15227            TYPE_LANG_SPECIFIC is really just a tree.  */
15228         ggc_mark_tree ((tree) lt);
15229     }
15230 }