gcc/cp/decl.c

   1 /* Process declarations and variables for C compiler.
   2    Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000
   3    Free Software Foundation, Inc.
   4    Contributed by Michael Tiemann (tiemann@cygnus.com)
   5
   6 This file is part of GNU CC.
   7
   8 GNU CC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2, or (at your option)
  11 any later version.
  12
  13 GNU CC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GNU CC; see the file COPYING.  If not, write to
  20 the Free Software Foundation, 59 Temple Place - Suite 330,
  21 Boston, MA 02111-1307, USA.  */
  22
  23
  24 /* Process declarations and symbol lookup for C front end.
  25    Also constructs types; the standard scalar types at initialization,
  26    and structure, union, array and enum types when they are declared.  */
  27
  28 /* ??? not all decl nodes are given the most useful possible
  29    line numbers.  For example, the CONST_DECLs for enum values.  */
  30
  31 #include "config.h"
  32 #include "system.h"
  33 #include "tree.h"
  34 #include "rtl.h"
  35 #include "expr.h"
  36 #include "flags.h"
  37 #include "cp-tree.h"
  38 #include "decl.h"
  39 #include "lex.h"
  40 #include "defaults.h"
  41 #include "output.h"
  42 #include "except.h"
  43 #include "toplev.h"
  44 #include "../hash.h"
  45 #include "defaults.h"
  46 #include "ggc.h"
  47
  48 extern int current_class_depth;
  49
  50 extern tree static_ctors, static_dtors;
  51
  52 extern tree global_namespace;
  53
  54 extern int (*valid_lang_attribute) PARAMS ((tree, tree, tree, tree));
  55
  56 /* Use garbage collection.  */
  57
  58 int ggc_p = 1;
  59
  60 #ifndef WCHAR_UNSIGNED
  61 #define WCHAR_UNSIGNED 0
  62 #endif
  63
  64 #ifndef CHAR_TYPE_SIZE
  65 #define CHAR_TYPE_SIZE BITS_PER_UNIT
  66 #endif
  67
  68 #ifndef BOOL_TYPE_SIZE
  69 #ifdef SLOW_BYTE_ACCESS
  70 /* In the new ABI, `bool' has size and alignment `1', on all
  71    platforms.  */
  72 #define BOOL_TYPE_SIZE \
  73   ((SLOW_BYTE_ACCESS && !flag_new_abi) ? (POINTER_SIZE) : (CHAR_TYPE_SIZE))
  74 #else
  75 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
  76 #endif
  77 #endif
  78
  79 /* We let tm.h override the types used here, to handle trivial differences
  80    such as the choice of unsigned int or long unsigned int for size_t.
  81    When machines start needing nontrivial differences in the size type,
  82    it would be best to do something here to figure out automatically
  83    from other information what type to use.  */
  84
  85 #ifndef SIZE_TYPE
  86 #define SIZE_TYPE "long unsigned int"
  87 #endif
  88
  89 #ifndef PTRDIFF_TYPE
  90 #define PTRDIFF_TYPE "long int"
  91 #endif
  92
  93 #ifndef WCHAR_TYPE
  94 #define WCHAR_TYPE "int"
  95 #endif
  96
  97 static tree grokparms                           PARAMS ((tree, int));
  98 static const char *redeclaration_error_message  PARAMS ((tree, tree));
  99
 100 static void push_binding_level PARAMS ((struct binding_level *, int,
 101                                       int));
 102 static void pop_binding_level PARAMS ((void));
 103 static void suspend_binding_level PARAMS ((void));
 104 static void resume_binding_level PARAMS ((struct binding_level *));
 105 static struct binding_level *make_binding_level PARAMS ((void));
 106 static void declare_namespace_level PARAMS ((void));
 107 static int decl_jump_unsafe PARAMS ((tree));
 108 static void storedecls PARAMS ((tree));
 109 static void require_complete_types_for_parms PARAMS ((tree));
 110 static int ambi_op_p PARAMS ((enum tree_code));
 111 static int unary_op_p PARAMS ((enum tree_code));
 112 static tree store_bindings PARAMS ((tree, tree));
 113 static tree lookup_tag_reverse PARAMS ((tree, tree));
 114 static tree obscure_complex_init PARAMS ((tree, tree));
 115 static tree lookup_name_real PARAMS ((tree, int, int, int));
 116 static void warn_extern_redeclared_static PARAMS ((tree, tree));
 117 static void grok_reference_init PARAMS ((tree, tree, tree));
 118 static tree grokfndecl PARAMS ((tree, tree, tree, tree, int,
 119                               enum overload_flags, tree,
 120                               tree, int, int, int, int, int, int, tree));
 121 static tree grokvardecl PARAMS ((tree, tree, RID_BIT_TYPE *, int, int, tree));
 122 static tree lookup_tag PARAMS ((enum tree_code, tree,
 123                               struct binding_level *, int));
 124 static void set_identifier_type_value_with_scope
 125         PARAMS ((tree, tree, struct binding_level *));
 126 static void record_builtin_type PARAMS ((enum rid, const char *, tree));
 127 static void record_unknown_type PARAMS ((tree, const char *));
 128 static tree build_library_fn_1 PARAMS ((tree, enum tree_code, tree));
 129 static int member_function_or_else PARAMS ((tree, tree, enum overload_flags));
 130 static void bad_specifiers PARAMS ((tree, const char *, int, int, int, int,
 131                                   int));
 132 static void lang_print_error_function PARAMS ((const char *));
 133 static tree maybe_process_template_type_declaration PARAMS ((tree, int, struct binding_level*));
 134 static void check_for_uninitialized_const_var PARAMS ((tree));
 135 static unsigned long typename_hash PARAMS ((hash_table_key));
 136 static boolean typename_compare PARAMS ((hash_table_key, hash_table_key));
 137 static void push_binding PARAMS ((tree, tree, struct binding_level*));
 138 static int add_binding PARAMS ((tree, tree));
 139 static void pop_binding PARAMS ((tree, tree));
 140 static tree local_variable_p_walkfn PARAMS ((tree *, int *, void *));
 141 static tree find_binding PARAMS ((tree, tree));
 142 static tree select_decl PARAMS ((tree, int));
 143 static int lookup_flags PARAMS ((int, int));
 144 static tree qualify_lookup PARAMS ((tree, int));
 145 static tree record_builtin_java_type PARAMS ((const char *, int));
 146 static const char *tag_name PARAMS ((enum tag_types code));
 147 static void find_class_binding_level PARAMS ((void));
 148 static struct binding_level *innermost_nonclass_level PARAMS ((void));
 149 static void warn_about_implicit_typename_lookup PARAMS ((tree, tree));
 150 static int walk_namespaces_r PARAMS ((tree, walk_namespaces_fn, void *));
 151 static int walk_globals_r PARAMS ((tree, void *));
 152 static void add_decl_to_level PARAMS ((tree, struct binding_level *));
 153 static tree make_label_decl PARAMS ((tree, int));
 154 static void use_label PARAMS ((tree));
 155 static void check_previous_goto_1 PARAMS ((tree, struct binding_level *, tree,
 156                                            const char *, int));
 157 static void check_previous_goto PARAMS ((struct named_label_use_list *));
 158 static void check_switch_goto PARAMS ((struct binding_level *));
 159 static void check_previous_gotos PARAMS ((tree));
 160 static void pop_label PARAMS ((tree, tree));
 161 static void pop_labels PARAMS ((tree));
 162 static void maybe_deduce_size_from_array_init PARAMS ((tree, tree));
 163 static void layout_var_decl PARAMS ((tree));
 164 static void maybe_commonize_var PARAMS ((tree));
 165 static tree check_initializer PARAMS ((tree, tree));
 166 static void make_rtl_for_nonlocal_decl PARAMS ((tree, tree, const char *));
 167 static void push_cp_function_context PARAMS ((struct function *));
 168 static void pop_cp_function_context PARAMS ((struct function *));
 169 static void mark_binding_level PARAMS ((void *));
 170 static void mark_named_label_lists PARAMS ((void *, void *));
 171 static void mark_cp_function_context PARAMS ((struct function *));
 172 static void mark_saved_scope PARAMS ((void *));
 173 static void mark_lang_function PARAMS ((struct language_function *));
 174 static void mark_stmt_tree PARAMS ((struct stmt_tree *));
 175 static void save_function_data PARAMS ((tree));
 176 static void check_function_type PARAMS ((tree));
 177 static void destroy_local_var PARAMS ((tree));
 178 static void finish_constructor_body PARAMS ((void));
 179 static void finish_destructor_body PARAMS ((void));
 180 static tree create_array_type_for_decl PARAMS ((tree, tree, tree));
 181 static tree get_atexit_node PARAMS ((void));
 182 static tree get_dso_handle_node PARAMS ((void));
 183 static tree start_cleanup_fn PARAMS ((void));
 184 static void end_cleanup_fn PARAMS ((void));
 185 static tree cp_make_fname_decl PARAMS ((tree, const char *, int));
 186 static void initialize_predefined_identifiers PARAMS ((void));
 187 static tree check_special_function_return_type
 188   PARAMS ((special_function_kind, tree, tree, tree));
 189 static tree push_cp_library_fn PARAMS ((enum tree_code, tree));
 190 static tree build_cp_library_fn PARAMS ((tree, enum tree_code, tree));
 191
 192 #if defined (DEBUG_CP_BINDING_LEVELS)
 193 static void indent PARAMS ((void));
 194 #endif
 195
 196 /* Erroneous argument lists can use this *IFF* they do not modify it.  */
 197 tree error_mark_list;
 198
 199 /* The following symbols are subsumed in the cp_global_trees array, and
 200    listed here individually for documentation purposes.
 201
 202    C++ extensions
 203         tree wchar_decl_node;
 204         tree void_zero_node;
 205
 206         tree vtable_entry_type;
 207         tree delta_type_node;
 208 #if 0
 209    Old rtti stuff.
 210         tree __baselist_desc_type_node;
 211         tree __i_desc_type_node, __m_desc_type_node;
 212         tree __t_desc_array_type, __i_desc_array_type, __m_desc_array_type;
 213 #endif
 214         tree __t_desc_type_node;
 215 #if 0
 216         tree __tp_desc_type_node;
 217 #endif
 218         tree ti_desc_type_node;
 219         tree bltn_desc_type_node, ptr_desc_type_node;
 220         tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
 221         tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
 222         tree ptm_desc_type_node;
 223         tree base_desc_type_node;
 224 #if 0
 225    Not needed yet?  May be needed one day?
 226         tree __bltn_desc_array_type, __user_desc_array_type, __class_desc_array_type;
 227         tree __ptr_desc_array_type, __attr_dec_array_type, __func_desc_array_type;
 228         tree __ptmf_desc_array_type, __ptmd_desc_array_type;
 229 #endif
 230
 231         tree class_type_node, record_type_node, union_type_node, enum_type_node;
 232         tree unknown_type_node;
 233
 234    Array type `vtable_entry_type[]'
 235
 236         tree vtbl_type_node;
 237         tree vtbl_ptr_type_node;
 238
 239    Namespaces,
 240
 241         tree std_node;
 242         tree abi_node;
 243
 244    A FUNCTION_DECL which can call `abort'.  Not necessarily the
 245    one that the user will declare, but sufficient to be called
 246    by routines that want to abort the program.
 247
 248         tree abort_fndecl;
 249
 250    The FUNCTION_DECL for the default `::operator delete'.
 251
 252         tree global_delete_fndecl;
 253
 254    Used by RTTI
 255         tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
 256         tree tinfo_var_id;
 257
 258 */
 259
 260 tree cp_global_trees[CPTI_MAX];
 261
 262 /* Indicates that there is a type value in some namespace, although
 263    that is not necessarily in scope at the moment.  */
 264
 265 static tree global_type_node;
 266
 267 /* Namespace std.  */
 268 int in_std;
 269
 270 /* Expect only namespace names now. */
 271 static int only_namespace_names;
 272
 273 /* If original DECL_RESULT of current function was a register,
 274    but due to being an addressable named return value, would up
 275    on the stack, this variable holds the named return value's
 276    original location.  */
 277
 278 #define original_result_rtx cp_function_chain->x_result_rtx
 279
 280 /* Used only for jumps to as-yet undefined labels, since jumps to
 281    defined labels can have their validity checked immediately.  */
 282
 283 struct named_label_use_list
 284 {
 285   struct binding_level *binding_level;
 286   tree names_in_scope;
 287   tree label_decl;
 288   const char *filename_o_goto;
 289   int lineno_o_goto;
 290   struct named_label_use_list *next;
 291 };
 292
 293 #define named_label_uses cp_function_chain->x_named_label_uses
 294
 295 /* A list of objects which have constructors or destructors
 296    which reside in the global scope.  The decl is stored in
 297    the TREE_VALUE slot and the initializer is stored
 298    in the TREE_PURPOSE slot.  */
 299 tree static_aggregates;
 300
 301 /* -- end of C++ */
 302
 303 /* A node for the integer constants 2, and 3.  */
 304
 305 tree integer_two_node, integer_three_node;
 306
 307 /* Parsing a function declarator leaves here a chain of structure
 308    and enum types declared in the parmlist.  */
 309
 310 static tree last_function_parm_tags;
 311
 312 /* Similar, for last_function_parm_tags.  */
 313 tree last_function_parms;
 314 static tree current_function_parm_tags;
 315
 316 /* A list of all LABEL_DECLs in the function that have names.  Here so
 317    we can clear out their names' definitions at the end of the
 318    function, and so we can check the validity of jumps to these labels.  */
 319
 320 struct named_label_list
 321 {
 322   struct binding_level *binding_level;
 323   tree names_in_scope;
 324   tree old_value;
 325   tree label_decl;
 326   tree bad_decls;
 327   int eh_region;
 328   struct named_label_list *next;
 329 };
 330
 331 #define named_labels cp_function_chain->x_named_labels
 332
 333 /* Set to 0 at beginning of a function definition, and whenever
 334    a label (case or named) is defined.  Set to value of expression
 335    returned from function when that value can be transformed into
 336    a named return value.  */
 337
 338 tree current_function_return_value;
 339
 340 /* Nonzero means use the ISO C99 dialect of C.  */
 341
 342 int flag_isoc99;
 343
 344 /* Nonzero means give `double' the same size as `float'.  */
 345
 346 extern int flag_short_double;
 347
 348 /* Nonzero means don't recognize any builtin functions.  */
 349
 350 extern int flag_no_builtin;
 351
 352 /* Nonzero means don't recognize the non-ANSI builtin functions.
 353    -ansi sets this.  */
 354
 355 extern int flag_no_nonansi_builtin;
 356
 357 /* Nonzero if we want to conserve space in the .o files.  We do this
 358    by putting uninitialized data and runtime initialized data into
 359    .common instead of .data at the expense of not flagging multiple
 360    definitions.  */
 361 extern int flag_conserve_space;
 362 \f
 363 /* C and C++ flags are in decl2.c.  */
 364
 365 /* Flag used when debugging spew.c */
 366
 367 extern int spew_debug;
 368
 369 /* A expression of value 0 with the same precision as a sizetype
 370    node, but signed.  */
 371 tree signed_size_zero_node;
 372
 373 /* The name of the anonymous namespace, throughout this translation
 374    unit.  */
 375 tree anonymous_namespace_name;
 376
 377 \f
 378 /* For each binding contour we allocate a binding_level structure
 379    which records the names defined in that contour.
 380    Contours include:
 381     0) the global one
 382     1) one for each function definition,
 383        where internal declarations of the parameters appear.
 384     2) one for each compound statement,
 385        to record its declarations.
 386
 387    The current meaning of a name can be found by searching the levels
 388    from the current one out to the global one.
 389
 390    Off to the side, may be the class_binding_level.  This exists only
 391    to catch class-local declarations.  It is otherwise nonexistent.
 392
 393    Also there may be binding levels that catch cleanups that must be
 394    run when exceptions occur.  Thus, to see whether a name is bound in
 395    the current scope, it is not enough to look in the
 396    CURRENT_BINDING_LEVEL.  You should use lookup_name_current_level
 397    instead.  */
 398
 399 /* Note that the information in the `names' component of the global contour
 400    is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers.  */
 401
 402 struct binding_level
 403   {
 404     /* A chain of _DECL nodes for all variables, constants, functions,
 405        and typedef types.  These are in the reverse of the order
 406        supplied.  There may be OVERLOADs on this list, too, but they
 407        are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD.  */
 408     tree names;
 409
 410     /* A list of structure, union and enum definitions, for looking up
 411        tag names.
 412        It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
 413        or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
 414        or ENUMERAL_TYPE node.
 415
 416        C++: the TREE_VALUE nodes can be simple types for
 417        component_bindings.  */
 418     tree tags;
 419
 420     /* A list of USING_DECL nodes. */
 421     tree usings;
 422
 423     /* A list of used namespaces. PURPOSE is the namespace,
 424        VALUE the common ancestor with this binding_level's namespace. */
 425     tree using_directives;
 426
 427     /* If this binding level is the binding level for a class, then
 428        class_shadowed is a TREE_LIST.  The TREE_PURPOSE of each node
 429        is the name of an entity bound in the class; the TREE_VALUE is
 430        the IDENTIFIER_CLASS_VALUE before we entered the class.  Thus,
 431        when leaving class scope, we can restore the
 432        IDENTIFIER_CLASS_VALUE by walking this list.  The TREE_TYPE is
 433        the DECL bound by this name in the class.  */
 434     tree class_shadowed;
 435
 436     /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
 437        is used for all binding levels.  */
 438     tree type_shadowed;
 439
 440     /* A TREE_LIST.  Each TREE_VALUE is the LABEL_DECL for a local
 441        label in this scope.  The TREE_PURPOSE is the previous value of
 442        the IDENTIFIER_LABEL VALUE.  */
 443     tree shadowed_labels;
 444
 445     /* For each level (except not the global one),
 446        a chain of BLOCK nodes for all the levels
 447        that were entered and exited one level down.  */
 448     tree blocks;
 449
 450     /* The BLOCK node for this level, if one has been preallocated.
 451        If 0, the BLOCK is allocated (if needed) when the level is popped.  */
 452     tree this_block;
 453
 454     /* The _TYPE node for this level, if parm_flag == 2.  */
 455     tree this_class;
 456
 457     /* The binding level which this one is contained in (inherits from).  */
 458     struct binding_level *level_chain;
 459
 460     /* List of decls in `names' that have incomplete
 461        structure or union types.  */
 462     tree incomplete;
 463
 464     /* List of VAR_DECLS saved from a previous for statement.
 465        These would be dead in ISO-conforming code, but might
 466        be referenced in ARM-era code.  These are stored in a
 467        TREE_LIST; the TREE_VALUE is the actual declaration.  */
 468     tree dead_vars_from_for;
 469
 470     /* 1 for the level that holds the parameters of a function.
 471        2 for the level that holds a class declaration.  */
 472     unsigned parm_flag : 2;
 473
 474     /* 1 means make a BLOCK for this level regardless of all else.
 475        2 for temporary binding contours created by the compiler.  */
 476     unsigned keep : 2;
 477
 478     /* Nonzero if this level "doesn't exist" for tags.  */
 479     unsigned tag_transparent : 1;
 480
 481     /* Nonzero if this level can safely have additional
 482        cleanup-needing variables added to it.  */
 483     unsigned more_cleanups_ok : 1;
 484     unsigned have_cleanups : 1;
 485
 486     /* Nonzero if this scope is for storing the decls for template
 487        parameters and generic decls; these decls will be discarded and
 488        replaced with a TEMPLATE_DECL.  */
 489     unsigned template_parms_p : 1;
 490
 491     /* Nonzero if this scope corresponds to the `<>' in a
 492        `template <>' clause.  Whenever this flag is set,
 493        TEMPLATE_PARMS_P will be set as well.  */
 494     unsigned template_spec_p : 1;
 495
 496     /* This is set for a namespace binding level.  */
 497     unsigned namespace_p : 1;
 498
 499     /* True if this level is that of a for-statement where we need to
 500        worry about ambiguous (ARM or ISO) scope rules.  */
 501     unsigned is_for_scope : 1;
 502
 503     /* True if this level corresponds to an EH region, as for a try block.
 504        Currently this information is only available while building the
 505        tree structure.  */
 506     unsigned eh_region : 1;
 507
 508     /* Four bits left for this word.  */
 509
 510 #if defined(DEBUG_CP_BINDING_LEVELS)
 511     /* Binding depth at which this level began.  */
 512     unsigned binding_depth;
 513 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 514   };
 515
 516 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
 517
 518 /* The binding level currently in effect.  */
 519
 520 #define current_binding_level                   \
 521   (cfun                                         \
 522    ? cp_function_chain->bindings                \
 523    : scope_chain->bindings)
 524
 525 /* The binding level of the current class, if any.  */
 526
 527 #define class_binding_level scope_chain->class_bindings
 528
 529 /* A chain of binding_level structures awaiting reuse.  */
 530
 531 static struct binding_level *free_binding_level;
 532
 533 /* The outermost binding level, for names of file scope.
 534    This is created when the compiler is started and exists
 535    through the entire run.  */
 536
 537 static struct binding_level *global_binding_level;
 538
 539 /* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
 540
 541 static int keep_next_level_flag;
 542
 543 #if defined(DEBUG_CP_BINDING_LEVELS)
 544 static int binding_depth = 0;
 545 static int is_class_level = 0;
 546
 547 static void
 548 indent ()
 549 {
 550   register unsigned i;
 551
 552   for (i = 0; i < binding_depth*2; i++)
 553     putc (' ', stderr);
 554 }
 555 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 556
 557 static tree pushdecl_with_scope PARAMS ((tree, struct binding_level *));
 558
 559 static void
 560 push_binding_level (newlevel, tag_transparent, keep)
 561      struct binding_level *newlevel;
 562      int tag_transparent, keep;
 563 {
 564   /* Add this level to the front of the chain (stack) of levels that
 565      are active.  */
 566   bzero ((char*) newlevel, sizeof (struct binding_level));
 567   newlevel->level_chain = current_binding_level;
 568   current_binding_level = newlevel;
 569   newlevel->tag_transparent = tag_transparent;
 570   newlevel->more_cleanups_ok = 1;
 571
 572   newlevel->keep = keep;
 573 #if defined(DEBUG_CP_BINDING_LEVELS)
 574   newlevel->binding_depth = binding_depth;
 575   indent ();
 576   fprintf (stderr, "push %s level 0x%08x line %d\n",
 577            (is_class_level) ? "class" : "block", newlevel, lineno);
 578   is_class_level = 0;
 579   binding_depth++;
 580 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 581 }
 582
 583 /* Find the innermost enclosing class scope, and reset
 584    CLASS_BINDING_LEVEL appropriately.  */
 585
 586 static void
 587 find_class_binding_level ()
 588 {
 589   struct binding_level *level = current_binding_level;
 590
 591   while (level && level->parm_flag != 2)
 592     level = level->level_chain;
 593   if (level && level->parm_flag == 2)
 594     class_binding_level = level;
 595   else
 596     class_binding_level = 0;
 597 }
 598
 599 static void
 600 pop_binding_level ()
 601 {
 602   if (global_binding_level)
 603     {
 604       /* Cannot pop a level, if there are none left to pop.  */
 605       if (current_binding_level == global_binding_level)
 606         my_friendly_abort (123);
 607     }
 608   /* Pop the current level, and free the structure for reuse.  */
 609 #if defined(DEBUG_CP_BINDING_LEVELS)
 610   binding_depth--;
 611   indent ();
 612   fprintf (stderr, "pop  %s level 0x%08x line %d\n",
 613           (is_class_level) ? "class" : "block",
 614           current_binding_level, lineno);
 615   if (is_class_level != (current_binding_level == class_binding_level))
 616     {
 617       indent ();
 618       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 619     }
 620   is_class_level = 0;
 621 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 622   {
 623     register struct binding_level *level = current_binding_level;
 624     current_binding_level = current_binding_level->level_chain;
 625     level->level_chain = free_binding_level;
 626 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
 627     if (level->binding_depth != binding_depth)
 628       abort ();
 629 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 630     free_binding_level = level;
 631     find_class_binding_level ();
 632   }
 633 }
 634
 635 static void
 636 suspend_binding_level ()
 637 {
 638   if (class_binding_level)
 639     current_binding_level = class_binding_level;
 640
 641   if (global_binding_level)
 642     {
 643       /* Cannot suspend a level, if there are none left to suspend.  */
 644       if (current_binding_level == global_binding_level)
 645         my_friendly_abort (123);
 646     }
 647   /* Suspend the current level.  */
 648 #if defined(DEBUG_CP_BINDING_LEVELS)
 649   binding_depth--;
 650   indent ();
 651   fprintf (stderr, "suspend  %s level 0x%08x line %d\n",
 652           (is_class_level) ? "class" : "block",
 653           current_binding_level, lineno);
 654   if (is_class_level != (current_binding_level == class_binding_level))
 655     {
 656       indent ();
 657       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 658     }
 659   is_class_level = 0;
 660 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 661   current_binding_level = current_binding_level->level_chain;
 662   find_class_binding_level ();
 663 }
 664
 665 static void
 666 resume_binding_level (b)
 667      struct binding_level *b;
 668 {
 669   /* Resuming binding levels is meant only for namespaces,
 670      and those cannot nest into classes. */
 671   my_friendly_assert(!class_binding_level, 386);
 672   /* Also, resuming a non-directly nested namespace is a no-no.  */
 673   my_friendly_assert(b->level_chain == current_binding_level, 386);
 674   current_binding_level = b;
 675 #if defined(DEBUG_CP_BINDING_LEVELS)
 676   b->binding_depth = binding_depth;
 677   indent ();
 678   fprintf (stderr, "resume %s level 0x%08x line %d\n",
 679            (is_class_level) ? "class" : "block", b, lineno);
 680   is_class_level = 0;
 681   binding_depth++;
 682 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 683 }
 684 \f
 685 /* Create a new `struct binding_level'.  */
 686
 687 static
 688 struct binding_level *
 689 make_binding_level ()
 690 {
 691   /* NOSTRICT */
 692   return (struct binding_level *) xmalloc (sizeof (struct binding_level));
 693 }
 694
 695 /* Nonzero if we are currently in the global binding level.  */
 696
 697 int
 698 global_bindings_p ()
 699 {
 700   return current_binding_level == global_binding_level;
 701 }
 702
 703 /* Return the innermost binding level that is not for a class scope.  */
 704
 705 static struct binding_level *
 706 innermost_nonclass_level ()
 707 {
 708   struct binding_level *b;
 709
 710   b = current_binding_level;
 711   while (b->parm_flag == 2)
 712     b = b->level_chain;
 713
 714   return b;
 715 }
 716
 717 /* Nonzero if we are currently in a toplevel binding level.  This
 718    means either the global binding level or a namespace in a toplevel
 719    binding level.  Since there are no non-toplevel namespace levels,
 720    this really means any namespace or template parameter level.  We
 721    also include a class whose context is toplevel.  */
 722
 723 int
 724 toplevel_bindings_p ()
 725 {
 726   struct binding_level *b = innermost_nonclass_level ();
 727
 728   return b->namespace_p || b->template_parms_p;
 729 }
 730
 731 /* Nonzero if this is a namespace scope, or if we are defining a class
 732    which is itself at namespace scope, or whose enclosing class is
 733    such a class, etc.  */
 734
 735 int
 736 namespace_bindings_p ()
 737 {
 738   struct binding_level *b = innermost_nonclass_level ();
 739
 740   return b->namespace_p;
 741 }
 742
 743 /* If KEEP is non-zero, make a BLOCK node for the next binding level,
 744    unconditionally.  Otherwise, use the normal logic to decide whether
 745    or not to create a BLOCK.  */
 746
 747 void
 748 keep_next_level (keep)
 749      int keep;
 750 {
 751   keep_next_level_flag = keep;
 752 }
 753
 754 /* Nonzero if the current level needs to have a BLOCK made.  */
 755
 756 int
 757 kept_level_p ()
 758 {
 759   return (current_binding_level->blocks != NULL_TREE
 760           || current_binding_level->keep
 761           || current_binding_level->names != NULL_TREE
 762           || (current_binding_level->tags != NULL_TREE
 763               && !current_binding_level->tag_transparent));
 764 }
 765
 766 static void
 767 declare_namespace_level ()
 768 {
 769   current_binding_level->namespace_p = 1;
 770 }
 771
 772 /* Returns non-zero if this scope was created to store template
 773    parameters.  */
 774
 775 int
 776 template_parm_scope_p ()
 777 {
 778   return current_binding_level->template_parms_p;
 779 }
 780
 781 /* Returns the kind of template specialization we are currently
 782    processing, given that it's declaration contained N_CLASS_SCOPES
 783    explicit scope qualifications.  */
 784
 785 tmpl_spec_kind
 786 current_tmpl_spec_kind (n_class_scopes)
 787      int n_class_scopes;
 788 {
 789   int n_template_parm_scopes = 0;
 790   int seen_specialization_p = 0;
 791   int innermost_specialization_p = 0;
 792   struct binding_level *b;
 793
 794   /* Scan through the template parameter scopes.  */
 795   for (b = current_binding_level; b->template_parms_p; b = b->level_chain)
 796     {
 797       /* If we see a specialization scope inside a parameter scope,
 798          then something is wrong.  That corresponds to a declaration
 799          like:
 800
 801             template <class T> template <> ...
 802
 803          which is always illegal since [temp.expl.spec] forbids the
 804          specialization of a class member template if the enclosing
 805          class templates are not explicitly specialized as well.  */
 806       if (b->template_spec_p)
 807         {
 808           if (n_template_parm_scopes == 0)
 809             innermost_specialization_p = 1;
 810           else
 811             seen_specialization_p = 1;
 812         }
 813       else if (seen_specialization_p == 1)
 814         return tsk_invalid_member_spec;
 815
 816       ++n_template_parm_scopes;
 817     }
 818
 819   /* Handle explicit instantiations.  */
 820   if (processing_explicit_instantiation)
 821     {
 822       if (n_template_parm_scopes != 0)
 823         /* We've seen a template parameter list during an explicit
 824            instantiation.  For example:
 825
 826              template <class T> template void f(int);
 827
 828            This is erroneous.  */
 829         return tsk_invalid_expl_inst;
 830       else
 831         return tsk_expl_inst;
 832     }
 833
 834   if (n_template_parm_scopes < n_class_scopes)
 835     /* We've not seen enough template headers to match all the
 836        specialized classes present.  For example:
 837
 838          template <class T> void R<T>::S<T>::f(int);
 839
 840        This is illegal; there needs to be one set of template
 841        parameters for each class.  */
 842     return tsk_insufficient_parms;
 843   else if (n_template_parm_scopes == n_class_scopes)
 844     /* We're processing a non-template declaration (even though it may
 845        be a member of a template class.)  For example:
 846
 847          template <class T> void S<T>::f(int);
 848
 849        The `class T' maches the `S<T>', leaving no template headers
 850        corresponding to the `f'.  */
 851     return tsk_none;
 852   else if (n_template_parm_scopes > n_class_scopes + 1)
 853     /* We've got too many template headers.  For example:
 854
 855          template <> template <class T> void f (T);
 856
 857        There need to be more enclosing classes.  */
 858     return tsk_excessive_parms;
 859   else
 860     /* This must be a template.  It's of the form:
 861
 862          template <class T> template <class U> void S<T>::f(U);
 863
 864        This is a specialization if the innermost level was a
 865        specialization; otherwise it's just a definition of the
 866        template.  */
 867     return innermost_specialization_p ? tsk_expl_spec : tsk_template;
 868 }
 869
 870 void
 871 set_class_shadows (shadows)
 872      tree shadows;
 873 {
 874   class_binding_level->class_shadowed = shadows;
 875 }
 876
 877 /* Enter a new binding level.
 878    If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
 879    not for that of tags.  */
 880
 881 void
 882 pushlevel (tag_transparent)
 883      int tag_transparent;
 884 {
 885   struct binding_level *newlevel;
 886
 887   if (cfun && !doing_semantic_analysis_p ())
 888     return;
 889
 890   /* Reuse or create a struct for this binding level.  */
 891 #if defined(DEBUG_CP_BINDING_LEVELS)
 892   if (0)
 893 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
 894   if (free_binding_level)
 895 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
 896     {
 897       newlevel = free_binding_level;
 898       free_binding_level = free_binding_level->level_chain;
 899     }
 900   else
 901     newlevel = make_binding_level ();
 902
 903   push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
 904   GNU_xref_start_scope ((HOST_WIDE_INT) newlevel);
 905   keep_next_level_flag = 0;
 906 }
 907
 908 /* Enter a new scope.  The KIND indicates what kind of scope is being
 909    created.  */
 910
 911 void
 912 begin_scope (sk)
 913      scope_kind sk;
 914 {
 915   pushlevel (0);
 916
 917   switch (sk)
 918     {
 919     case sk_template_spec:
 920       current_binding_level->template_spec_p = 1;
 921       /* Fall through.  */
 922
 923     case sk_template_parms:
 924       current_binding_level->template_parms_p = 1;
 925       break;
 926
 927     default:
 928       my_friendly_abort (20000309);
 929     }
 930 }
 931
 932 /* Exit the current scope.  */
 933
 934 void
 935 finish_scope ()
 936 {
 937   poplevel (0, 0, 0);
 938 }
 939
 940 void
 941 note_level_for_for ()
 942 {
 943   current_binding_level->is_for_scope = 1;
 944 }
 945
 946 /* Record that the current binding level represents a try block.  */
 947
 948 void
 949 note_level_for_eh ()
 950 {
 951   current_binding_level->eh_region = 1;
 952 }
 953
 954 /* For a binding between a name and an entity at a block scope,
 955    this is the `struct binding_level' for the block.  */
 956 #define BINDING_LEVEL(NODE) \
 957    (((struct tree_binding*)NODE)->scope.level)
 958
 959 /* Make DECL the innermost binding for ID.  The LEVEL is the binding
 960    level at which this declaration is being bound.  */
 961
 962 static void
 963 push_binding (id, decl, level)
 964      tree id;
 965      tree decl;
 966      struct binding_level* level;
 967 {
 968   tree binding;
 969
 970   binding = make_node (CPLUS_BINDING);
 971
 972   /* Now, fill in the binding information.  */
 973   BINDING_VALUE (binding) = decl;
 974   BINDING_TYPE (binding) = NULL_TREE;
 975   BINDING_LEVEL (binding) = level;
 976   INHERITED_VALUE_BINDING_P (binding) = 0;
 977   LOCAL_BINDING_P (binding) = (level != class_binding_level);
 978   BINDING_HAS_LEVEL_P (binding) = 1;
 979
 980   /* And put it on the front of the list of bindings for ID.  */
 981   TREE_CHAIN (binding) = IDENTIFIER_BINDING (id);
 982   IDENTIFIER_BINDING (id) = binding;
 983 }
 984
 985 /* ID is already bound in the current scope.  But, DECL is an
 986    additional binding for ID in the same scope.  This is the `struct
 987    stat' hack whereby a non-typedef class-name or enum-name can be
 988    bound at the same level as some other kind of entity.  It's the
 989    responsibility of the caller to check that inserting this name is
 990    legal here.  Returns nonzero if the new binding was successful.  */
 991 static int
 992 add_binding (id, decl)
 993      tree id;
 994      tree decl;
 995 {
 996   tree binding = IDENTIFIER_BINDING (id);
 997   int ok = 1;
 998
 999   if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
1000     /* The new name is the type name.  */
1001     BINDING_TYPE (binding) = decl;
1002   else if (!BINDING_VALUE (binding))
1003     /* This situation arises when push_class_level_binding moves an
1004        inherited type-binding out of the way to make room for a new
1005        value binding.  */
1006     BINDING_VALUE (binding) = decl;
1007   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
1008            && DECL_ARTIFICIAL (BINDING_VALUE (binding)))
1009     {
1010       /* The old binding was a type name.  It was placed in
1011          BINDING_VALUE because it was thought, at the point it was
1012          declared, to be the only entity with such a name.  Move the
1013          type name into the type slot; it is now hidden by the new
1014          binding.  */
1015       BINDING_TYPE (binding) = BINDING_VALUE (binding);
1016       BINDING_VALUE (binding) = decl;
1017       INHERITED_VALUE_BINDING_P (binding) = 0;
1018     }
1019   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
1020            && TREE_CODE (decl) == TYPE_DECL
1021            && DECL_NAME (decl) == DECL_NAME (BINDING_VALUE (binding))
1022            && same_type_p (TREE_TYPE (decl),
1023                            TREE_TYPE (BINDING_VALUE (binding))))
1024     /* We have two typedef-names, both naming the same type to have
1025        the same name.  This is OK because of:
1026
1027          [dcl.typedef]
1028
1029          In a given scope, a typedef specifier can be used to redefine
1030          the name of any type declared in that scope to refer to the
1031          type to which it already refers.  */
1032     ok = 0;
1033   /* There can be two block-scope declarations of the same variable,
1034      so long as they are `extern' declarations.  */
1035   else if (TREE_CODE (decl) == VAR_DECL
1036            && TREE_CODE (BINDING_VALUE (binding)) == VAR_DECL
1037            && DECL_EXTERNAL (decl)
1038            && DECL_EXTERNAL (BINDING_VALUE (binding)))
1039     {
1040       duplicate_decls (decl, BINDING_VALUE (binding));
1041       ok = 0;
1042     }
1043   else
1044     {
1045       cp_error ("declaration of `%#D'", decl);
1046       cp_error_at ("conflicts with previous declaration `%#D'",
1047                    BINDING_VALUE (binding));
1048       ok = 0;
1049     }
1050
1051   return ok;
1052 }
1053
1054 /* Add DECL to the list of things declared in B.  */
1055
1056 static void
1057 add_decl_to_level (decl, b)
1058      tree decl;
1059      struct binding_level *b;
1060 {
1061   /* We build up the list in reverse order, and reverse it later if
1062      necessary.  */
1063   TREE_CHAIN (decl) = b->names;
1064   b->names = decl;
1065 }
1066
1067 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1068    binding level.  If PUSH_USING is set in FLAGS, we know that DECL
1069    doesn't really belong to this binding level, that it got here
1070    through a using-declaration.  */
1071
1072 void
1073 push_local_binding (id, decl, flags)
1074      tree id;
1075      tree decl;
1076      int flags;
1077 {
1078   struct binding_level *b;
1079
1080   /* Skip over any local classes.  This makes sense if we call
1081      push_local_binding with a friend decl of a local class.  */
1082   b = current_binding_level;
1083   while (b->parm_flag == 2)
1084     b = b->level_chain;
1085
1086   if (lookup_name_current_level (id))
1087     {
1088       /* Supplement the existing binding.  */
1089       if (!add_binding (id, decl))
1090         /* It didn't work.  Something else must be bound at this
1091            level.  Do not add DECL to the list of things to pop
1092            later.  */
1093         return;
1094     }
1095   else
1096     /* Create a new binding.  */
1097     push_binding (id, decl, b);
1098
1099   if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1100     /* We must put the OVERLOAD into a TREE_LIST since the
1101        TREE_CHAIN of an OVERLOAD is already used.  Similarly for
1102        decls that got here through a using-declaration.  */
1103     decl = build_tree_list (NULL_TREE, decl);
1104
1105   /* And put DECL on the list of things declared by the current
1106      binding level.  */
1107   add_decl_to_level (decl, b);
1108 }
1109
1110 /* Bind DECL to ID in the class_binding_level.  Returns nonzero if the
1111    binding was successful.  */
1112
1113 int
1114 push_class_binding (id, decl)
1115      tree id;
1116      tree decl;
1117 {
1118   int result = 1;
1119   tree binding = IDENTIFIER_BINDING (id);
1120   tree context;
1121
1122   /* Note that we declared this value so that we can issue an error if
1123      this an illegal redeclaration of a name already used for some
1124      other purpose.  */
1125   note_name_declared_in_class (id, decl);
1126
1127   if (binding && BINDING_LEVEL (binding) == class_binding_level)
1128     /* Supplement the existing binding.  */
1129     result = add_binding (id, decl);
1130   else
1131     /* Create a new binding.  */
1132     push_binding (id, decl, class_binding_level);
1133
1134   /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1135      class-level declaration.  Note that we do not use DECL here
1136      because of the possibility of the `struct stat' hack; if DECL is
1137      a class-name or enum-name we might prefer a field-name, or some
1138      such.  */
1139   IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
1140
1141   /* If this is a binding from a base class, mark it as such.  */
1142   binding = IDENTIFIER_BINDING (id);
1143   if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
1144     {
1145       /* Any implicit typename must be from a base-class.  The
1146          context for an implicit typename declaration is always
1147          the derived class in which the lookup was done, so the checks
1148          based on the context of DECL below will not trigger.  */
1149       if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl))
1150         INHERITED_VALUE_BINDING_P (binding) = 1;
1151       else
1152         {
1153           if (TREE_CODE (decl) == OVERLOAD)
1154             context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
1155           else
1156             {
1157               my_friendly_assert (DECL_P (decl), 0);
1158               context = CP_DECL_CONTEXT (decl);
1159             }
1160
1161           if (is_properly_derived_from (current_class_type, context))
1162             INHERITED_VALUE_BINDING_P (binding) = 1;
1163           else
1164             INHERITED_VALUE_BINDING_P (binding) = 0;
1165         }
1166     }
1167   else if (BINDING_VALUE (binding) == decl)
1168     /* We only encounter a TREE_LIST when push_class_decls detects an
1169        ambiguity.  Such an ambiguity can be overridden by a definition
1170        in this class.  */
1171     INHERITED_VALUE_BINDING_P (binding) = 1;
1172
1173   return result;
1174 }
1175
1176 /* Remove the binding for DECL which should be the innermost binding
1177    for ID.  */
1178
1179 static void
1180 pop_binding (id, decl)
1181      tree id;
1182      tree decl;
1183 {
1184   tree binding;
1185
1186   if (id == NULL_TREE)
1187     /* It's easiest to write the loops that call this function without
1188        checking whether or not the entities involved have names.  We
1189        get here for such an entity.  */
1190     return;
1191
1192   /* Get the innermost binding for ID.  */
1193   binding = IDENTIFIER_BINDING (id);
1194
1195   /* The name should be bound.  */
1196   my_friendly_assert (binding != NULL_TREE, 0);
1197
1198   /* The DECL will be either the ordinary binding or the type
1199      binding for this identifier.  Remove that binding.  */
1200   if (BINDING_VALUE (binding) == decl)
1201     BINDING_VALUE (binding) = NULL_TREE;
1202   else if (BINDING_TYPE (binding) == decl)
1203     BINDING_TYPE (binding) = NULL_TREE;
1204   else
1205     my_friendly_abort (0);
1206
1207   if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
1208     /* We're completely done with the innermost binding for this
1209        identifier.  Unhook it from the list of bindings.  */
1210     IDENTIFIER_BINDING (id) = TREE_CHAIN (binding);
1211 }
1212
1213 /* When a label goes out of scope, check to see if that label was used
1214    in a valid manner, and issue any appropriate warnings or errors.  */
1215
1216 static void
1217 pop_label (label, old_value)
1218      tree label;
1219      tree old_value;
1220 {
1221   if (!processing_template_decl && doing_semantic_analysis_p ())
1222     {
1223       if (DECL_INITIAL (label) == NULL_TREE)
1224         {
1225           cp_error_at ("label `%D' used but not defined", label);
1226           /* Avoid crashing later.  */
1227           define_label (input_filename, 1, DECL_NAME (label));
1228         }
1229       else if (warn_unused_label && !TREE_USED (label))
1230         cp_warning_at ("label `%D' defined but not used", label);
1231     }
1232
1233   SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
1234 }
1235
1236 /* At the end of a function, all labels declared within the fucntion
1237    go out of scope.  BLOCK is the top-level block for the
1238    function.  */
1239
1240 static void
1241 pop_labels (block)
1242      tree block;
1243 {
1244   struct named_label_list *link;
1245
1246   /* Clear out the definitions of all label names, since their scopes
1247      end here.  */
1248   for (link = named_labels; link; link = link->next)
1249     {
1250       pop_label (link->label_decl, link->old_value);
1251       /* Put the labels into the "variables" of the top-level block,
1252          so debugger can see them.  */
1253       TREE_CHAIN (link->label_decl) = BLOCK_VARS (block);
1254       BLOCK_VARS (block) = link->label_decl;
1255     }
1256
1257   named_labels = NULL;
1258 }
1259
1260 /* Exit a binding level.
1261    Pop the level off, and restore the state of the identifier-decl mappings
1262    that were in effect when this level was entered.
1263
1264    If KEEP == 1, this level had explicit declarations, so
1265    and create a "block" (a BLOCK node) for the level
1266    to record its declarations and subblocks for symbol table output.
1267
1268    If FUNCTIONBODY is nonzero, this level is the body of a function,
1269    so create a block as if KEEP were set and also clear out all
1270    label names.
1271
1272    If REVERSE is nonzero, reverse the order of decls before putting
1273    them into the BLOCK.  */
1274
1275 tree
1276 poplevel (keep, reverse, functionbody)
1277      int keep;
1278      int reverse;
1279      int functionbody;
1280 {
1281   register tree link;
1282   /* The chain of decls was accumulated in reverse order.
1283      Put it into forward order, just for cleanliness.  */
1284   tree decls;
1285   int tmp = functionbody;
1286   int real_functionbody;
1287   tree tags;
1288   tree subblocks;
1289   tree block = NULL_TREE;
1290   tree decl;
1291   int block_previously_created;
1292   int leaving_for_scope;
1293
1294   if (cfun && !doing_semantic_analysis_p ())
1295     return NULL_TREE;
1296
1297   my_friendly_assert (current_binding_level->parm_flag != 2,
1298                       19990916);
1299
1300   real_functionbody = (current_binding_level->keep == 2
1301                        ? ((functionbody = 0), tmp) : functionbody);
1302   tags = functionbody >= 0 ? current_binding_level->tags : 0;
1303   subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1304
1305   my_friendly_assert (!current_binding_level->class_shadowed,
1306                       19990414);
1307
1308   /* We used to use KEEP == 2 to indicate that the new block should go
1309      at the beginning of the list of blocks at this binding level,
1310      rather than the end.  This hack is no longer used.  */
1311   my_friendly_assert (keep == 0 || keep == 1, 0);
1312
1313   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
1314                       (HOST_WIDE_INT) current_binding_level->level_chain,
1315                       current_binding_level->parm_flag,
1316                       current_binding_level->keep);
1317
1318   if (current_binding_level->keep == 1)
1319     keep = 1;
1320
1321   /* Any uses of undefined labels, and any defined labels, now operate
1322      under constraints of next binding contour.  */
1323   if (cfun && !functionbody)
1324     {
1325       struct binding_level *level_chain;
1326       level_chain = current_binding_level->level_chain;
1327       if (level_chain)
1328         {
1329           struct named_label_use_list *uses;
1330           struct named_label_list *labels;
1331           for (labels = named_labels; labels; labels = labels->next)
1332             if (labels->binding_level == current_binding_level)
1333               {
1334                 tree decl;
1335                 if (current_binding_level->eh_region)
1336                   labels->eh_region = 1;
1337                 for (decl = labels->names_in_scope; decl;
1338                      decl = TREE_CHAIN (decl))
1339                   if (decl_jump_unsafe (decl))
1340                     labels->bad_decls = tree_cons (NULL_TREE, decl,
1341                                                    labels->bad_decls);
1342                 labels->binding_level = level_chain;
1343                 labels->names_in_scope = level_chain->names;
1344               }
1345
1346           for (uses = named_label_uses; uses; uses = uses->next)
1347             if (uses->binding_level == current_binding_level)
1348               {
1349                 uses->binding_level = level_chain;
1350                 uses->names_in_scope = level_chain->names;
1351               }
1352         }
1353     }
1354
1355   /* Get the decls in the order they were written.
1356      Usually current_binding_level->names is in reverse order.
1357      But parameter decls were previously put in forward order.  */
1358
1359   if (reverse)
1360     current_binding_level->names
1361       = decls = nreverse (current_binding_level->names);
1362   else
1363     decls = current_binding_level->names;
1364
1365   /* Output any nested inline functions within this block
1366      if they weren't already output.  */
1367   for (decl = decls; decl; decl = TREE_CHAIN (decl))
1368     if (TREE_CODE (decl) == FUNCTION_DECL
1369         && ! TREE_ASM_WRITTEN (decl)
1370         && DECL_INITIAL (decl) != NULL_TREE
1371         && TREE_ADDRESSABLE (decl)
1372         && decl_function_context (decl) == current_function_decl)
1373       {
1374         /* If this decl was copied from a file-scope decl
1375            on account of a block-scope extern decl,
1376            propagate TREE_ADDRESSABLE to the file-scope decl.  */
1377         if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1378           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1379         else
1380           {
1381             push_function_context ();
1382             output_inline_function (decl);
1383             pop_function_context ();
1384           }
1385       }
1386
1387   /* When not in function-at-a-time mode, expand_end_bindings will
1388      warn about unused variables.  But, in function-at-a-time mode
1389      expand_end_bindings is not passed the list of variables in the
1390      current scope, and therefore no warning is emitted.  So, we
1391      explicitly warn here.  */
1392   if (!processing_template_decl)
1393     warn_about_unused_variables (getdecls ());
1394
1395   /* If there were any declarations or structure tags in that level,
1396      or if this level is a function body,
1397      create a BLOCK to record them for the life of this function.  */
1398   block = NULL_TREE;
1399   block_previously_created = (current_binding_level->this_block != NULL_TREE);
1400   if (block_previously_created)
1401     block = current_binding_level->this_block;
1402   else if (keep == 1 || functionbody)
1403     block = make_node (BLOCK);
1404   if (block != NULL_TREE)
1405     {
1406       if (block_previously_created)
1407         {
1408           if (decls || tags || subblocks)
1409             {
1410               if (BLOCK_VARS (block))
1411                 warning ("internal compiler error: debugging info corrupted");
1412
1413               BLOCK_VARS (block) = decls;
1414
1415               /* We can have previous subblocks and new subblocks when
1416                  doing fixup_gotos with complex cleanups.  We chain the new
1417                  subblocks onto the end of any pre-existing subblocks.  */
1418               BLOCK_SUBBLOCKS (block) = chainon (BLOCK_SUBBLOCKS (block),
1419                                                  subblocks);
1420             }
1421         }
1422       else
1423         {
1424           BLOCK_VARS (block) = decls;
1425           BLOCK_SUBBLOCKS (block) = subblocks;
1426         }
1427     }
1428
1429   /* In each subblock, record that this is its superior.  */
1430   if (keep >= 0)
1431     for (link = subblocks; link; link = TREE_CHAIN (link))
1432       BLOCK_SUPERCONTEXT (link) = block;
1433
1434   /* We still support the old for-scope rules, whereby the variables
1435      in a for-init statement were in scope after the for-statement
1436      ended.  We only use the new rules in flag_new_for_scope is
1437      nonzero.  */
1438   leaving_for_scope
1439     = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1440
1441   /* Remove declarations for all the DECLs in this level.  */
1442   for (link = decls; link; link = TREE_CHAIN (link))
1443     {
1444       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL)
1445         {
1446           tree outer_binding
1447             = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1448           tree ns_binding;
1449
1450           if (!outer_binding)
1451             ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1452           else
1453             ns_binding = NULL_TREE;
1454
1455           if (outer_binding
1456               && (BINDING_LEVEL (outer_binding)
1457                   == current_binding_level->level_chain))
1458             /* We have something like:
1459
1460                  int i;
1461                  for (int i; ;);
1462
1463                and we are leaving the `for' scope.  There's no reason to
1464                keep the binding of the inner `i' in this case.  */
1465             pop_binding (DECL_NAME (link), link);
1466           else if ((outer_binding
1467                     && (TREE_CODE (BINDING_VALUE (outer_binding))
1468                         == TYPE_DECL))
1469                    || (ns_binding
1470                        && TREE_CODE (ns_binding) == TYPE_DECL))
1471             /* Here, we have something like:
1472
1473                  typedef int I;
1474
1475                  void f () {
1476                    for (int I; ;);
1477                  }
1478
1479                We must pop the for-scope binding so we know what's a
1480                type and what isn't.  */
1481             pop_binding (DECL_NAME (link), link);
1482           else
1483             {
1484               /* Mark this VAR_DECL as dead so that we can tell we left it
1485                  there only for backward compatibility.  */
1486               DECL_DEAD_FOR_LOCAL (link) = 1;
1487
1488               /* Keep track of what should of have happenned when we
1489                  popped the binding.  */
1490               if (outer_binding && BINDING_VALUE (outer_binding))
1491                 DECL_SHADOWED_FOR_VAR (link)
1492                   = BINDING_VALUE (outer_binding);
1493
1494               /* Add it to the list of dead variables in the next
1495                  outermost binding to that we can remove these when we
1496                  leave that binding.  */
1497               current_binding_level->level_chain->dead_vars_from_for
1498                 = tree_cons (NULL_TREE, link,
1499                              current_binding_level->level_chain->
1500                              dead_vars_from_for);
1501
1502               /* Although we don't pop the CPLUS_BINDING, we do clear
1503                  its BINDING_LEVEL since the level is going away now.  */
1504               BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1505                 = 0;
1506             }
1507         }
1508       else
1509         {
1510           /* Remove the binding.  */
1511           decl = link;
1512           if (TREE_CODE (decl) == TREE_LIST)
1513             decl = TREE_VALUE (decl);
1514           if (DECL_P (decl))
1515             pop_binding (DECL_NAME (decl), decl);
1516           else if (TREE_CODE (decl) == OVERLOAD)
1517             pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1518           else
1519             my_friendly_abort (0);
1520         }
1521     }
1522
1523   /* Remove declarations for any `for' variables from inner scopes
1524      that we kept around.  */
1525   for (link = current_binding_level->dead_vars_from_for;
1526        link; link = TREE_CHAIN (link))
1527     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1528
1529   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
1530   for (link = current_binding_level->type_shadowed;
1531        link; link = TREE_CHAIN (link))
1532     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1533
1534   /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
1535   for (link = current_binding_level->shadowed_labels;
1536        link;
1537        link = TREE_CHAIN (link))
1538     pop_label (TREE_VALUE (link), TREE_PURPOSE (link));
1539
1540   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1541      list if a `using' declaration put them there.  The debugging
1542      back-ends won't understand OVERLOAD, so we remove them here.
1543      Because the BLOCK_VARS are (temporarily) shared with
1544      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1545      popped all the bindings.  */
1546   if (block)
1547     {
1548       tree* d;
1549
1550       for (d = &BLOCK_VARS (block); *d; )
1551         {
1552           if (TREE_CODE (*d) == TREE_LIST)
1553             *d = TREE_CHAIN (*d);
1554           else
1555             d = &TREE_CHAIN (*d);
1556         }
1557     }
1558
1559   /* If the level being exited is the top level of a function,
1560      check over all the labels.  */
1561   if (functionbody)
1562     {
1563       /* Since this is the top level block of a function, the vars are
1564          the function's parameters.  Don't leave them in the BLOCK
1565          because they are found in the FUNCTION_DECL instead.  */
1566       BLOCK_VARS (block) = 0;
1567       pop_labels (block);
1568     }
1569
1570   tmp = current_binding_level->keep;
1571
1572   pop_binding_level ();
1573   if (functionbody)
1574     DECL_INITIAL (current_function_decl) = block;
1575   else if (block)
1576     {
1577       if (!block_previously_created)
1578         current_binding_level->blocks
1579           = chainon (current_binding_level->blocks, block);
1580     }
1581   /* If we did not make a block for the level just exited,
1582      any blocks made for inner levels
1583      (since they cannot be recorded as subblocks in that level)
1584      must be carried forward so they will later become subblocks
1585      of something else.  */
1586   else if (subblocks)
1587     current_binding_level->blocks
1588       = chainon (current_binding_level->blocks, subblocks);
1589
1590   /* Each and every BLOCK node created here in `poplevel' is important
1591      (e.g. for proper debugging information) so if we created one
1592      earlier, mark it as "used".  */
1593   if (block)
1594     TREE_USED (block) = 1;
1595
1596   /* Take care of compiler's internal binding structures.  */
1597   if (tmp == 2)
1598     {
1599       tree scope_stmts;
1600
1601       scope_stmts
1602         = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1603       if (block)
1604         {
1605           SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1606           SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1607         }
1608
1609       block = poplevel (keep, reverse, functionbody);
1610     }
1611
1612   return block;
1613 }
1614
1615 /* Delete the node BLOCK from the current binding level.
1616    This is used for the block inside a stmt expr ({...})
1617    so that the block can be reinserted where appropriate.  */
1618
1619 void
1620 delete_block (block)
1621      tree block;
1622 {
1623   tree t;
1624   if (current_binding_level->blocks == block)
1625     current_binding_level->blocks = TREE_CHAIN (block);
1626   for (t = current_binding_level->blocks; t;)
1627     {
1628       if (TREE_CHAIN (t) == block)
1629         TREE_CHAIN (t) = TREE_CHAIN (block);
1630       else
1631         t = TREE_CHAIN (t);
1632     }
1633   TREE_CHAIN (block) = NULL_TREE;
1634   /* Clear TREE_USED which is always set by poplevel.
1635      The flag is set again if insert_block is called.  */
1636   TREE_USED (block) = 0;
1637 }
1638
1639 /* Insert BLOCK at the end of the list of subblocks of the
1640    current binding level.  This is used when a BIND_EXPR is expanded,
1641    to handle the BLOCK node inside the BIND_EXPR.  */
1642
1643 void
1644 insert_block (block)
1645      tree block;
1646 {
1647   TREE_USED (block) = 1;
1648   current_binding_level->blocks
1649     = chainon (current_binding_level->blocks, block);
1650 }
1651
1652 /* Set the BLOCK node for the innermost scope
1653    (the one we are currently in).  */
1654
1655 void
1656 set_block (block)
1657     register tree block;
1658 {
1659   current_binding_level->this_block = block;
1660 }
1661
1662 /* Do a pushlevel for class declarations.  */
1663
1664 void
1665 pushlevel_class ()
1666 {
1667   register struct binding_level *newlevel;
1668
1669   /* Reuse or create a struct for this binding level.  */
1670 #if defined(DEBUG_CP_BINDING_LEVELS)
1671   if (0)
1672 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1673   if (free_binding_level)
1674 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1675     {
1676       newlevel = free_binding_level;
1677       free_binding_level = free_binding_level->level_chain;
1678     }
1679   else
1680     newlevel = make_binding_level ();
1681
1682 #if defined(DEBUG_CP_BINDING_LEVELS)
1683   is_class_level = 1;
1684 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1685
1686   push_binding_level (newlevel, 0, 0);
1687
1688   class_binding_level = current_binding_level;
1689   class_binding_level->parm_flag = 2;
1690   class_binding_level->this_class = current_class_type;
1691 }
1692
1693 /* ...and a poplevel for class declarations.  */
1694
1695 void
1696 poplevel_class ()
1697 {
1698   register struct binding_level *level = class_binding_level;
1699   tree shadowed;
1700
1701   my_friendly_assert (level != 0, 354);
1702
1703   /* If we're leaving a toplevel class, don't bother to do the setting
1704      of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1705      shouldn't even be used when current_class_type isn't set, and second,
1706      if we don't touch it here, we're able to use the cache effect if the
1707      next time we're entering a class scope, it is the same class.  */
1708   if (current_class_depth != 1)
1709     {
1710       struct binding_level* b;
1711
1712       /* Clear out our IDENTIFIER_CLASS_VALUEs.  */
1713       for (shadowed = level->class_shadowed;
1714            shadowed;
1715            shadowed = TREE_CHAIN (shadowed))
1716         IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1717
1718       /* Find the next enclosing class, and recreate
1719          IDENTIFIER_CLASS_VALUEs appropriate for that class.  */
1720       b = level->level_chain;
1721       while (b && b->parm_flag != 2)
1722         b = b->level_chain;
1723
1724       if (b)
1725         for (shadowed = b->class_shadowed;
1726              shadowed;
1727              shadowed = TREE_CHAIN (shadowed))
1728           {
1729             tree t;
1730
1731             t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1732             while (t && BINDING_LEVEL (t) != b)
1733               t = TREE_CHAIN (t);
1734
1735             if (t)
1736               IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1737                 = BINDING_VALUE (t);
1738           }
1739     }
1740   else
1741     /* Remember to save what IDENTIFIER's were bound in this scope so we
1742        can recover from cache misses.  */
1743     {
1744       previous_class_type = current_class_type;
1745       previous_class_values = class_binding_level->class_shadowed;
1746     }
1747   for (shadowed = level->type_shadowed;
1748        shadowed;
1749        shadowed = TREE_CHAIN (shadowed))
1750     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1751
1752   /* Remove the bindings for all of the class-level declarations.  */
1753   for (shadowed = level->class_shadowed;
1754        shadowed;
1755        shadowed = TREE_CHAIN (shadowed))
1756     pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1757
1758   GNU_xref_end_scope ((HOST_WIDE_INT) class_binding_level,
1759                       (HOST_WIDE_INT) class_binding_level->level_chain,
1760                       class_binding_level->parm_flag,
1761                       class_binding_level->keep);
1762
1763   /* Now, pop out of the binding level which we created up in the
1764      `pushlevel_class' routine.  */
1765 #if defined(DEBUG_CP_BINDING_LEVELS)
1766   is_class_level = 1;
1767 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1768
1769   pop_binding_level ();
1770 }
1771
1772 /* We are entering the scope of a class.  Clear IDENTIFIER_CLASS_VALUE
1773    for any names in enclosing classes.  */
1774
1775 void
1776 clear_identifier_class_values ()
1777 {
1778   tree t;
1779
1780   if (!class_binding_level)
1781     return;
1782
1783   for (t = class_binding_level->class_shadowed;
1784        t;
1785        t = TREE_CHAIN (t))
1786     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1787 }
1788
1789 /* Returns non-zero if T is a virtual function table.  */
1790
1791 int
1792 vtable_decl_p (t, data)
1793      tree t;
1794      void *data ATTRIBUTE_UNUSED;
1795 {
1796   return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1797 }
1798
1799 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1800    functions.  */
1801
1802 int
1803 vtype_decl_p (t, data)
1804      tree t;
1805      void *data ATTRIBUTE_UNUSED;
1806 {
1807   return (TREE_CODE (t) == TYPE_DECL
1808           && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE
1809           && TYPE_POLYMORPHIC_P (TREE_TYPE (t)));
1810 }
1811
1812 /* Return the declarations that are members of the namespace NS.  */
1813
1814 tree
1815 cp_namespace_decls (ns)
1816      tree ns;
1817 {
1818   return NAMESPACE_LEVEL (ns)->names;
1819 }
1820
1821 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1822    itself, calling F for each.  The DATA is passed to F as well.  */
1823
1824 static int
1825 walk_namespaces_r (namespace, f, data)
1826      tree namespace;
1827      walk_namespaces_fn f;
1828      void *data;
1829 {
1830   tree current;
1831   int result = 0;
1832
1833   result |= (*f) (namespace, data);
1834
1835   for (current = cp_namespace_decls (namespace);
1836        current;
1837        current = TREE_CHAIN (current))
1838     {
1839       if (TREE_CODE (current) != NAMESPACE_DECL
1840           || DECL_NAMESPACE_ALIAS (current))
1841         continue;
1842       if (!DECL_LANG_SPECIFIC (current))
1843         {
1844           /* Hmm. std. */
1845           my_friendly_assert (current == std_node, 393);
1846           continue;
1847         }
1848
1849       /* We found a namespace.  */
1850       result |= walk_namespaces_r (current, f, data);
1851     }
1852
1853   return result;
1854 }
1855
1856 /* Walk all the namespaces, calling F for each.  The DATA is passed to
1857    F as well.  */
1858
1859 int
1860 walk_namespaces (f, data)
1861      walk_namespaces_fn f;
1862      void *data;
1863 {
1864   return walk_namespaces_r (global_namespace, f, data);
1865 }
1866
1867 struct walk_globals_data {
1868   walk_globals_pred p;
1869   walk_globals_fn f;
1870   void *data;
1871 };
1872
1873 /* Walk the global declarations in NAMESPACE.  Whenever one is found
1874    for which P returns non-zero, call F with its address.  If any call
1875    to F returns a non-zero value, return a non-zero value.  */
1876
1877 static int
1878 walk_globals_r (namespace, data)
1879      tree namespace;
1880      void *data;
1881 {
1882   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1883   walk_globals_pred p = wgd->p;
1884   walk_globals_fn f = wgd->f;
1885   void *d = wgd->data;
1886   tree *t;
1887   int result = 0;
1888
1889   t = &NAMESPACE_LEVEL (namespace)->names;
1890
1891   while (*t)
1892     {
1893       tree glbl = *t;
1894
1895       if ((*p) (glbl, d))
1896         result |= (*f) (t, d);
1897
1898       /* If F changed *T, then *T still points at the next item to
1899          examine.  */
1900       if (*t == glbl)
1901         t = &TREE_CHAIN (*t);
1902     }
1903
1904   return result;
1905 }
1906
1907 /* Walk the global declarations.  Whenever one is found for which P
1908    returns non-zero, call F with its address.  If any call to F
1909    returns a non-zero value, return a non-zero value.  */
1910
1911 int
1912 walk_globals (p, f, data)
1913      walk_globals_pred p;
1914      walk_globals_fn f;
1915      void *data;
1916 {
1917   struct walk_globals_data wgd;
1918   wgd.p = p;
1919   wgd.f = f;
1920   wgd.data = data;
1921
1922   return walk_namespaces (walk_globals_r, &wgd);
1923 }
1924
1925 /* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
1926    DATA is non-NULL, this is the last time we will call
1927    wrapup_global_declarations for this NAMESPACE.  */
1928
1929 int
1930 wrapup_globals_for_namespace (namespace, data)
1931      tree namespace;
1932      void *data;
1933 {
1934   tree globals = cp_namespace_decls (namespace);
1935   int len = list_length (globals);
1936   tree *vec = (tree *) alloca (sizeof (tree) * len);
1937   int i;
1938   int result;
1939   tree decl;
1940   int last_time = (data != 0);
1941
1942   if (last_time && namespace == global_namespace)
1943     /* Let compile_file handle the global namespace.  */
1944     return 0;
1945
1946   /* Process the decls in reverse order--earliest first.
1947      Put them into VEC from back to front, then take out from front.  */
1948
1949   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1950     {
1951       /* Pretend we've output an unused static variable.  This ensures
1952          that the toplevel __FUNCTION__ etc won't be emitted, unless
1953          needed. */
1954       if (TREE_CODE (decl) == VAR_DECL && DECL_ARTIFICIAL (decl)
1955           && !TREE_PUBLIC (decl) && !TREE_USED (decl))
1956         {
1957           TREE_ASM_WRITTEN (decl) = 1;
1958           DECL_IGNORED_P (decl) = 1;
1959         }
1960       vec[len - i - 1] = decl;
1961     }
1962
1963   if (last_time)
1964     {
1965       check_global_declarations (vec, len);
1966       return 0;
1967     }
1968
1969   /* Temporarily mark vtables as external.  That prevents
1970      wrapup_global_declarations from writing them out; we must process
1971      them ourselves in finish_vtable_vardecl.  */
1972   for (i = 0; i < len; ++i)
1973     if (vtable_decl_p (vec[i], /*data=*/0) && !DECL_EXTERNAL (vec[i]))
1974       {
1975         DECL_NOT_REALLY_EXTERN (vec[i]) = 1;
1976         DECL_EXTERNAL (vec[i]) = 1;
1977       }
1978
1979   /* Write out any globals that need to be output.  */
1980   result = wrapup_global_declarations (vec, len);
1981
1982   /* Undo the hack to DECL_EXTERNAL above.  */
1983   for (i = 0; i < len; ++i)
1984     if (vtable_decl_p (vec[i], /*data=*/0)
1985         && DECL_NOT_REALLY_EXTERN (vec[i]))
1986       {
1987         DECL_NOT_REALLY_EXTERN (vec[i]) = 0;
1988         DECL_EXTERNAL (vec[i]) = 0;
1989       }
1990
1991   return result;
1992 }
1993
1994 \f
1995 /* Mark ARG (which is really a struct binding_level **) for GC.  */
1996
1997 static void
1998 mark_binding_level (arg)
1999      void *arg;
2000 {
2001   struct binding_level *lvl = *(struct binding_level **)arg;
2002
2003   for (; lvl; lvl = lvl->level_chain)
2004     {
2005       ggc_mark_tree (lvl->names);
2006       ggc_mark_tree (lvl->tags);
2007       ggc_mark_tree (lvl->usings);
2008       ggc_mark_tree (lvl->using_directives);
2009       ggc_mark_tree (lvl->class_shadowed);
2010       ggc_mark_tree (lvl->type_shadowed);
2011       ggc_mark_tree (lvl->shadowed_labels);
2012       ggc_mark_tree (lvl->blocks);
2013       ggc_mark_tree (lvl->this_block);
2014       ggc_mark_tree (lvl->this_class);
2015       ggc_mark_tree (lvl->incomplete);
2016       ggc_mark_tree (lvl->dead_vars_from_for);
2017     }
2018 }
2019
2020 static void
2021 mark_named_label_lists (labs, uses)
2022      void *labs;
2023      void *uses;
2024 {
2025   struct named_label_list *l = *(struct named_label_list **)labs;
2026   struct named_label_use_list *u = *(struct named_label_use_list **)uses;
2027
2028   for (; l; l = l->next)
2029     {
2030       ggc_mark (l);
2031       mark_binding_level (l->binding_level);
2032       ggc_mark_tree (l->old_value);
2033       ggc_mark_tree (l->label_decl);
2034       ggc_mark_tree (l->bad_decls);
2035     }
2036
2037   for (; u; u = u->next)
2038     ggc_mark (u);
2039 }
2040 \f
2041 /* For debugging.  */
2042 static int no_print_functions = 0;
2043 static int no_print_builtins = 0;
2044
2045 void
2046 print_binding_level (lvl)
2047      struct binding_level *lvl;
2048 {
2049   tree t;
2050   int i = 0, len;
2051   fprintf (stderr, " blocks=");
2052   fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
2053   fprintf (stderr, " n_incomplete=%d parm_flag=%d keep=%d",
2054            list_length (lvl->incomplete), lvl->parm_flag, lvl->keep);
2055   if (lvl->tag_transparent)
2056     fprintf (stderr, " tag-transparent");
2057   if (lvl->more_cleanups_ok)
2058     fprintf (stderr, " more-cleanups-ok");
2059   if (lvl->have_cleanups)
2060     fprintf (stderr, " have-cleanups");
2061   fprintf (stderr, "\n");
2062   if (lvl->names)
2063     {
2064       fprintf (stderr, " names:\t");
2065       /* We can probably fit 3 names to a line?  */
2066       for (t = lvl->names; t; t = TREE_CHAIN (t))
2067         {
2068           if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
2069             continue;
2070           if (no_print_builtins
2071               && (TREE_CODE (t) == TYPE_DECL)
2072               && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
2073             continue;
2074
2075           /* Function decls tend to have longer names.  */
2076           if (TREE_CODE (t) == FUNCTION_DECL)
2077             len = 3;
2078           else
2079             len = 2;
2080           i += len;
2081           if (i > 6)
2082             {
2083               fprintf (stderr, "\n\t");
2084               i = len;
2085             }
2086           print_node_brief (stderr, "", t, 0);
2087           if (t == error_mark_node)
2088             break;
2089         }
2090       if (i)
2091         fprintf (stderr, "\n");
2092     }
2093   if (lvl->tags)
2094     {
2095       fprintf (stderr, " tags:\t");
2096       i = 0;
2097       for (t = lvl->tags; t; t = TREE_CHAIN (t))
2098         {
2099           if (TREE_PURPOSE (t) == NULL_TREE)
2100             len = 3;
2101           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2102             len = 2;
2103           else
2104             len = 4;
2105           i += len;
2106           if (i > 5)
2107             {
2108               fprintf (stderr, "\n\t");
2109               i = len;
2110             }
2111           if (TREE_PURPOSE (t) == NULL_TREE)
2112             {
2113               print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
2114               fprintf (stderr, ">");
2115             }
2116           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2117             print_node_brief (stderr, "", TREE_VALUE (t), 0);
2118           else
2119             {
2120               print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
2121               print_node_brief (stderr, "", TREE_VALUE (t), 0);
2122               fprintf (stderr, ">");
2123             }
2124         }
2125       if (i)
2126         fprintf (stderr, "\n");
2127     }
2128   if (lvl->class_shadowed)
2129     {
2130       fprintf (stderr, " class-shadowed:");
2131       for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
2132         {
2133           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2134         }
2135       fprintf (stderr, "\n");
2136     }
2137   if (lvl->type_shadowed)
2138     {
2139       fprintf (stderr, " type-shadowed:");
2140       for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
2141         {
2142           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2143         }
2144       fprintf (stderr, "\n");
2145     }
2146 }
2147
2148 void
2149 print_other_binding_stack (stack)
2150      struct binding_level *stack;
2151 {
2152   struct binding_level *level;
2153   for (level = stack; level != global_binding_level; level = level->level_chain)
2154     {
2155       fprintf (stderr, "binding level ");
2156       fprintf (stderr, HOST_PTR_PRINTF, level);
2157       fprintf (stderr, "\n");
2158       print_binding_level (level);
2159     }
2160 }
2161
2162 void
2163 print_binding_stack ()
2164 {
2165   struct binding_level *b;
2166   fprintf (stderr, "current_binding_level=");
2167   fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
2168   fprintf (stderr, "\nclass_binding_level=");
2169   fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
2170   fprintf (stderr, "\nglobal_binding_level=");
2171   fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
2172   fprintf (stderr, "\n");
2173   if (class_binding_level)
2174     {
2175       for (b = class_binding_level; b; b = b->level_chain)
2176         if (b == current_binding_level)
2177           break;
2178       if (b)
2179         b = class_binding_level;
2180       else
2181         b = current_binding_level;
2182     }
2183   else
2184     b = current_binding_level;
2185   print_other_binding_stack (b);
2186   fprintf (stderr, "global:\n");
2187   print_binding_level (global_binding_level);
2188 }
2189
2190 /* Namespace binding access routines: The namespace_bindings field of
2191    the identifier is polymorphic, with three possible values:
2192    NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2193    indicating the BINDING_VALUE of global_namespace. */
2194
2195 /* Check whether the a binding for the name to scope is known.
2196    Assumes that the bindings of the name are already a list
2197    of bindings. Returns the binding found, or NULL_TREE. */
2198
2199 static tree
2200 find_binding (name, scope)
2201      tree name;
2202      tree scope;
2203 {
2204   tree iter, prev = NULL_TREE;
2205
2206   scope = ORIGINAL_NAMESPACE (scope);
2207
2208   for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2209        iter = TREE_CHAIN (iter))
2210     {
2211       my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2212       if (BINDING_SCOPE (iter) == scope)
2213         {
2214           /* Move binding found to the front of the list, so
2215              subsequent lookups will find it faster. */
2216           if (prev)
2217             {
2218               TREE_CHAIN (prev) = TREE_CHAIN (iter);
2219               TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2220               IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2221             }
2222           return iter;
2223         }
2224       prev = iter;
2225     }
2226   return NULL_TREE;
2227 }
2228
2229 /* Always returns a binding for name in scope. If the
2230    namespace_bindings is not a list, convert it to one first.
2231    If no binding is found, make a new one. */
2232
2233 tree
2234 binding_for_name (name, scope)
2235      tree name;
2236      tree scope;
2237 {
2238   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2239   tree result;
2240
2241   scope = ORIGINAL_NAMESPACE (scope);
2242
2243   if (b && TREE_CODE (b) != CPLUS_BINDING)
2244     {
2245       /* Get rid of optimization for global scope. */
2246       IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2247       BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2248       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2249     }
2250   if (b && (result = find_binding (name, scope)))
2251     return result;
2252   /* Not found, make a new one. */
2253   result = make_node (CPLUS_BINDING);
2254   TREE_CHAIN (result) = b;
2255   IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2256   BINDING_SCOPE (result) = scope;
2257   BINDING_TYPE (result) = NULL_TREE;
2258   BINDING_VALUE (result) = NULL_TREE;
2259   return result;
2260 }
2261
2262 /* Return the binding value for name in scope, considering that
2263    namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2264
2265 tree
2266 namespace_binding (name, scope)
2267      tree name;
2268      tree scope;
2269 {
2270   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2271   if (b == NULL_TREE)
2272     return NULL_TREE;
2273   if (scope == NULL_TREE)
2274     scope = global_namespace;
2275   if (TREE_CODE (b) != CPLUS_BINDING)
2276     return (scope == global_namespace) ? b : NULL_TREE;
2277   name = find_binding (name,scope);
2278   if (name == NULL_TREE)
2279     return name;
2280   return BINDING_VALUE (name);
2281 }
2282
2283 /* Set the binding value for name in scope. If modifying the binding
2284    of global_namespace is attempted, try to optimize it. */
2285
2286 void
2287 set_namespace_binding (name, scope, val)
2288      tree name;
2289      tree scope;
2290      tree val;
2291 {
2292   tree b;
2293
2294   if (scope == NULL_TREE)
2295     scope = global_namespace;
2296
2297   if (scope == global_namespace)
2298     {
2299       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2300       if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2301         {
2302           IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2303           return;
2304         }
2305     }
2306   b = binding_for_name (name, scope);
2307   BINDING_VALUE (b) = val;
2308 }
2309
2310 /* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
2311    select a name that is unique to this compilation unit.  */
2312
2313 void
2314 push_namespace (name)
2315      tree name;
2316 {
2317   tree d = NULL_TREE;
2318   int need_new = 1;
2319   int implicit_use = 0;
2320   int global = 0;
2321   if (!global_namespace)
2322     {
2323       /* This must be ::. */
2324       my_friendly_assert (name == get_identifier ("::"), 377);
2325       global = 1;
2326     }
2327   else if (!name)
2328     {
2329       /* The name of anonymous namespace is unique for the translation
2330          unit.  */
2331       if (!anonymous_namespace_name)
2332         anonymous_namespace_name = get_file_function_name ('N');
2333       name = anonymous_namespace_name;
2334       d = IDENTIFIER_NAMESPACE_VALUE (name);
2335       if (d)
2336         /* Reopening anonymous namespace.  */
2337         need_new = 0;
2338       implicit_use = 1;
2339     }
2340   else if (current_namespace == global_namespace
2341            && name == DECL_NAME (std_node))
2342     {
2343       in_std++;
2344       return;
2345     }
2346   else
2347     {
2348       /* Check whether this is an extended namespace definition. */
2349       d = IDENTIFIER_NAMESPACE_VALUE (name);
2350       if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2351         {
2352           need_new = 0;
2353           if (DECL_NAMESPACE_ALIAS (d))
2354             {
2355               cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
2356                         d, DECL_NAMESPACE_ALIAS (d));
2357               d = DECL_NAMESPACE_ALIAS (d);
2358             }
2359         }
2360     }
2361
2362   if (need_new)
2363     {
2364       /* Make a new namespace, binding the name to it. */
2365       d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2366       /* The global namespace is not pushed, and the global binding
2367          level is set elsewhere.  */
2368       if (!global)
2369         {
2370           DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
2371           d = pushdecl (d);
2372           pushlevel (0);
2373           declare_namespace_level ();
2374           NAMESPACE_LEVEL (d) = current_binding_level;
2375         }
2376     }
2377   else
2378     resume_binding_level (NAMESPACE_LEVEL (d));
2379
2380   if (implicit_use)
2381     do_using_directive (d);
2382   /* Enter the name space. */
2383   current_namespace = d;
2384 }
2385
2386 /* Pop from the scope of the current namespace.  */
2387
2388 void
2389 pop_namespace ()
2390 {
2391   if (current_namespace == global_namespace)
2392     {
2393       my_friendly_assert (in_std>0, 980421);
2394       in_std--;
2395       return;
2396     }
2397   current_namespace = CP_DECL_CONTEXT (current_namespace);
2398   /* The binding level is not popped, as it might be re-opened later.  */
2399   suspend_binding_level ();
2400 }
2401
2402 /* Push into the scope of the namespace NS, even if it is deeply
2403    nested within another namespace.  */
2404
2405 void
2406 push_nested_namespace (ns)
2407      tree ns;
2408 {
2409   if (ns == global_namespace)
2410     push_to_top_level ();
2411   else
2412     {
2413       push_nested_namespace (CP_DECL_CONTEXT (ns));
2414       push_namespace (DECL_NAME (ns));
2415     }
2416 }
2417
2418 /* Pop back from the scope of the namespace NS, which was previously
2419    entered with push_nested_namespace.  */
2420
2421 void
2422 pop_nested_namespace (ns)
2423      tree ns;
2424 {
2425   while (ns != global_namespace)
2426     {
2427       pop_namespace ();
2428       ns = CP_DECL_CONTEXT (ns);
2429     }
2430
2431   pop_from_top_level ();
2432 }
2433
2434 \f
2435 /* Subroutines for reverting temporarily to top-level for instantiation
2436    of templates and such.  We actually need to clear out the class- and
2437    local-value slots of all identifiers, so that only the global values
2438    are at all visible.  Simply setting current_binding_level to the global
2439    scope isn't enough, because more binding levels may be pushed.  */
2440 struct saved_scope *scope_chain;
2441
2442 /* Mark ST for GC.  */
2443
2444 static void
2445 mark_stmt_tree (st)
2446      struct stmt_tree *st;
2447 {
2448   ggc_mark_tree (st->x_last_stmt);
2449   ggc_mark_tree (st->x_last_expr_type);
2450 }
2451
2452 /* Mark ARG (which is really a struct saved_scope **) for GC.  */
2453
2454 static void
2455 mark_saved_scope (arg)
2456      void *arg;
2457 {
2458   struct saved_scope *t = *(struct saved_scope **)arg;
2459   while (t)
2460     {
2461       mark_binding_level (&t->class_bindings);
2462       ggc_mark_tree (t->old_bindings);
2463       ggc_mark_tree (t->old_namespace);
2464       ggc_mark_tree (t->class_name);
2465       ggc_mark_tree (t->class_type);
2466       ggc_mark_tree (t->access_specifier);
2467       ggc_mark_tree (t->function_decl);
2468       if (t->lang_base)
2469         ggc_mark_tree_varray (t->lang_base);
2470       ggc_mark_tree (t->lang_name);
2471       ggc_mark_tree (t->x_function_parms);
2472       ggc_mark_tree (t->template_parms);
2473       ggc_mark_tree (t->x_previous_class_type);
2474       ggc_mark_tree (t->x_previous_class_values);
2475       ggc_mark_tree (t->x_saved_tree);
2476       ggc_mark_tree (t->incomplete);
2477       ggc_mark_tree (t->lookups);
2478
2479       mark_stmt_tree (&t->x_stmt_tree);
2480       mark_binding_level (&t->bindings);
2481       t = t->prev;
2482     }
2483 }
2484
2485 static tree
2486 store_bindings (names, old_bindings)
2487      tree names, old_bindings;
2488 {
2489   tree t;
2490   for (t = names; t; t = TREE_CHAIN (t))
2491     {
2492       tree binding, t1, id;
2493
2494       if (TREE_CODE (t) == TREE_LIST)
2495         id = TREE_PURPOSE (t);
2496       else
2497         id = DECL_NAME (t);
2498
2499       if (!id
2500           /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2501              we have no IDENTIFIER_BINDING if we have left the class
2502              scope, but cached the class-level declarations.  */
2503           || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2504         continue;
2505
2506       for (t1 = old_bindings; t1; t1 = TREE_CHAIN (t1))
2507         if (TREE_VEC_ELT (t1, 0) == id)
2508           goto skip_it;
2509
2510       binding = make_tree_vec (4);
2511
2512       if (id)
2513         {
2514           my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2515           TREE_VEC_ELT (binding, 0) = id;
2516           TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2517           TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2518           TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2519           IDENTIFIER_BINDING (id) = NULL_TREE;
2520           IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2521         }
2522       TREE_CHAIN (binding) = old_bindings;
2523       old_bindings = binding;
2524     skip_it:
2525       ;
2526     }
2527   return old_bindings;
2528 }
2529
2530 void
2531 maybe_push_to_top_level (pseudo)
2532      int pseudo;
2533 {
2534   struct saved_scope *s;
2535   struct binding_level *b;
2536   tree old_bindings;
2537   int need_pop;
2538
2539   s = (struct saved_scope *) xcalloc (1, sizeof (struct saved_scope));
2540
2541   b = scope_chain ? current_binding_level : 0;
2542
2543   /* If we're in the middle of some function, save our state.  */
2544   if (cfun)
2545     {
2546       need_pop = 1;
2547       push_function_context_to (NULL_TREE);
2548     }
2549   else
2550     need_pop = 0;
2551
2552   old_bindings = NULL_TREE;
2553   if (scope_chain && previous_class_type)
2554     old_bindings = store_bindings (previous_class_values, old_bindings);
2555
2556   /* Have to include global_binding_level, because class-level decls
2557      aren't listed anywhere useful.  */
2558   for (; b; b = b->level_chain)
2559     {
2560       tree t;
2561
2562       /* Template IDs are inserted into the global level. If they were
2563          inserted into namespace level, finish_file wouldn't find them
2564          when doing pending instantiations. Therefore, don't stop at
2565          namespace level, but continue until :: .  */
2566       if (b == global_binding_level || (pseudo && b->template_parms_p))
2567         break;
2568
2569       old_bindings = store_bindings (b->names, old_bindings);
2570       /* We also need to check class_shadowed to save class-level type
2571          bindings, since pushclass doesn't fill in b->names.  */
2572       if (b->parm_flag == 2)
2573         old_bindings = store_bindings (b->class_shadowed, old_bindings);
2574
2575       /* Unwind type-value slots back to top level.  */
2576       for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2577         SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2578     }
2579   s->prev = scope_chain;
2580   s->old_bindings = old_bindings;
2581   s->bindings = b;
2582   s->need_pop_function_context = need_pop;
2583   s->function_decl = current_function_decl;
2584
2585   scope_chain = s;
2586   current_function_decl = NULL_TREE;
2587   VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2588   current_lang_stack = &VARRAY_TREE (current_lang_base, 0);
2589   current_lang_name = lang_name_cplusplus;
2590   strict_prototype = strict_prototypes_lang_cplusplus;
2591   current_namespace = global_namespace;
2592 }
2593
2594 void
2595 push_to_top_level ()
2596 {
2597   maybe_push_to_top_level (0);
2598 }
2599
2600 void
2601 pop_from_top_level ()
2602 {
2603   struct saved_scope *s = scope_chain;
2604   tree t;
2605
2606   /* Clear out class-level bindings cache.  */
2607   if (previous_class_type)
2608     invalidate_class_lookup_cache ();
2609
2610   VARRAY_FREE (current_lang_base);
2611
2612   scope_chain = s->prev;
2613   for (t = s->old_bindings; t; t = TREE_CHAIN (t))
2614     {
2615       tree id = TREE_VEC_ELT (t, 0);
2616       if (id)
2617         {
2618           SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2619           IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2620           IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2621         }
2622     }
2623
2624   if (current_lang_name == lang_name_cplusplus)
2625     strict_prototype = strict_prototypes_lang_cplusplus;
2626   else if (current_lang_name == lang_name_c)
2627     strict_prototype = strict_prototypes_lang_c;
2628
2629   /* If we were in the middle of compiling a function, restore our
2630      state.  */
2631   if (s->need_pop_function_context)
2632     pop_function_context_from (NULL_TREE);
2633   current_function_decl = s->function_decl;
2634
2635   free (s);
2636 }
2637 \f
2638 /* Push a definition of struct, union or enum tag "name".
2639    into binding_level "b".   "type" should be the type node,
2640    We assume that the tag "name" is not already defined.
2641
2642    Note that the definition may really be just a forward reference.
2643    In that case, the TYPE_SIZE will be a NULL_TREE.
2644
2645    C++ gratuitously puts all these tags in the name space.  */
2646
2647 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2648    record the shadowed value for this binding contour.  TYPE is
2649    the type that ID maps to.  */
2650
2651 static void
2652 set_identifier_type_value_with_scope (id, type, b)
2653      tree id;
2654      tree type;
2655      struct binding_level *b;
2656 {
2657   if (!b->namespace_p)
2658     {
2659       /* Shadow the marker, not the real thing, so that the marker
2660          gets restored later. */
2661       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2662       b->type_shadowed
2663         = tree_cons (id, old_type_value, b->type_shadowed);
2664     }
2665   else
2666     {
2667       tree binding = binding_for_name (id, current_namespace);
2668       BINDING_TYPE (binding) = type;
2669       /* Store marker instead of real type. */
2670       type = global_type_node;
2671     }
2672   SET_IDENTIFIER_TYPE_VALUE (id, type);
2673 }
2674
2675 /* As set_identifier_type_value_with_scope, but using current_binding_level.  */
2676
2677 void
2678 set_identifier_type_value (id, type)
2679      tree id;
2680      tree type;
2681 {
2682   set_identifier_type_value_with_scope (id, type, current_binding_level);
2683 }
2684
2685 /* Return the type associated with id. */
2686
2687 tree
2688 identifier_type_value (id)
2689      tree id;
2690 {
2691   /* There is no type with that name, anywhere. */
2692   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2693     return NULL_TREE;
2694   /* This is not the type marker, but the real thing. */
2695   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2696     return REAL_IDENTIFIER_TYPE_VALUE (id);
2697   /* Have to search for it. It must be on the global level, now.
2698      Ask lookup_name not to return non-types. */
2699   id = lookup_name_real (id, 2, 1, 0);
2700   if (id)
2701     return TREE_TYPE (id);
2702   return NULL_TREE;
2703 }
2704
2705 /* Pop off extraneous binding levels left over due to syntax errors.
2706
2707    We don't pop past namespaces, as they might be valid.  */
2708
2709 void
2710 pop_everything ()
2711 {
2712 #ifdef DEBUG_CP_BINDING_LEVELS
2713   fprintf (stderr, "XXX entering pop_everything ()\n");
2714 #endif
2715   while (!toplevel_bindings_p ())
2716     {
2717       if (current_binding_level->parm_flag == 2)
2718         pop_nested_class ();
2719       else
2720         poplevel (0, 0, 0);
2721     }
2722 #ifdef DEBUG_CP_BINDING_LEVELS
2723   fprintf (stderr, "XXX leaving pop_everything ()\n");
2724 #endif
2725 }
2726
2727 /* The type TYPE is being declared.  If it is a class template, or a
2728    specialization of a class template, do any processing required and
2729    perform error-checking.  If IS_FRIEND is non-zero, this TYPE is
2730    being declared a friend.  B is the binding level at which this TYPE
2731    should be bound.
2732
2733    Returns the TYPE_DECL for TYPE, which may have been altered by this
2734    processing.  */
2735
2736 static tree
2737 maybe_process_template_type_declaration (type, globalize, b)
2738      tree type;
2739      int globalize;
2740      struct binding_level* b;
2741 {
2742   tree decl = TYPE_NAME (type);
2743
2744   if (processing_template_parmlist)
2745     /* You can't declare a new template type in a template parameter
2746        list.  But, you can declare a non-template type:
2747
2748          template <class A*> struct S;
2749
2750        is a forward-declaration of `A'.  */
2751     ;
2752   else
2753     {
2754       maybe_check_template_type (type);
2755
2756       my_friendly_assert (IS_AGGR_TYPE (type)
2757                           || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2758
2759
2760       if (processing_template_decl)
2761         {
2762           /* This may change after the call to
2763              push_template_decl_real, but we want the original value.  */
2764           tree name = DECL_NAME (decl);
2765
2766           decl = push_template_decl_real (decl, globalize);
2767           /* If the current binding level is the binding level for the
2768              template parameters (see the comment in
2769              begin_template_parm_list) and the enclosing level is a class
2770              scope, and we're not looking at a friend, push the
2771              declaration of the member class into the class scope.  In the
2772              friend case, push_template_decl will already have put the
2773              friend into global scope, if appropriate.  */
2774           if (TREE_CODE (type) != ENUMERAL_TYPE
2775               && !globalize && b->template_parms_p
2776               && b->level_chain->parm_flag == 2)
2777             {
2778               finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2779               /* Put this tag on the list of tags for the class, since
2780                  that won't happen below because B is not the class
2781                  binding level, but is instead the pseudo-global level.  */
2782               b->level_chain->tags =
2783                 tree_cons (name, type, b->level_chain->tags);
2784               if (!COMPLETE_TYPE_P (current_class_type))
2785                 CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2786             }
2787         }
2788     }
2789
2790   return decl;
2791 }
2792
2793 /* In C++, you don't have to write `struct S' to refer to `S'; you
2794    can just use `S'.  We accomplish this by creating a TYPE_DECL as
2795    if the user had written `typedef struct S S'.  Create and return
2796    the TYPE_DECL for TYPE.  */
2797
2798 tree
2799 create_implicit_typedef (name, type)
2800      tree name;
2801      tree type;
2802 {
2803   tree decl;
2804
2805   decl = build_decl (TYPE_DECL, name, type);
2806   DECL_ARTIFICIAL (decl) = 1;
2807   /* There are other implicit type declarations, like the one *within*
2808      a class that allows you to write `S::S'.  We must distinguish
2809      amongst these.  */
2810   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2811   TYPE_NAME (type) = decl;
2812
2813   return decl;
2814 }
2815
2816 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2817    Normally put it into the inner-most non-tag-transparent scope,
2818    but if GLOBALIZE is true, put it in the inner-most non-class scope.
2819    The latter is needed for implicit declarations.  */
2820
2821 void
2822 pushtag (name, type, globalize)
2823      tree name, type;
2824      int globalize;
2825 {
2826   register struct binding_level *b;
2827
2828   b = current_binding_level;
2829   while (b->tag_transparent
2830          || (globalize && b->parm_flag == 2))
2831     b = b->level_chain;
2832
2833   b->tags = tree_cons (name, type, b->tags);
2834
2835   if (name)
2836     {
2837       /* Do C++ gratuitous typedefing.  */
2838       if (IDENTIFIER_TYPE_VALUE (name) != type)
2839         {
2840           register tree d = NULL_TREE;
2841           int in_class = 0;
2842           tree context = TYPE_CONTEXT (type);
2843
2844           if (! context)
2845             {
2846               tree cs = current_scope ();
2847
2848               if (! globalize)
2849                 context = cs;
2850               else if (cs != NULL_TREE && TYPE_P (cs))
2851                 /* When declaring a friend class of a local class, we want
2852                    to inject the newly named class into the scope
2853                    containing the local class, not the namespace scope.  */
2854                 context = decl_function_context (get_type_decl (cs));
2855             }
2856           if (!context)
2857             context = current_namespace;
2858
2859           if ((b->template_parms_p && b->level_chain->parm_flag == 2)
2860               || b->parm_flag == 2)
2861             in_class = 1;
2862
2863           if (current_lang_name == lang_name_java)
2864             TYPE_FOR_JAVA (type) = 1;
2865
2866           d = create_implicit_typedef (name, type);
2867           DECL_CONTEXT (d) = FROB_CONTEXT (context);
2868           if (! in_class)
2869             set_identifier_type_value_with_scope (name, type, b);
2870
2871           d = maybe_process_template_type_declaration (type,
2872                                                        globalize, b);
2873
2874           if (b->parm_flag == 2)
2875             {
2876               if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2877                 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2878                    class.  But if it's a member template class, we
2879                    want the TEMPLATE_DECL, not the TYPE_DECL, so this
2880                    is done later.  */
2881                 finish_member_declaration (d);
2882               else
2883                 pushdecl_class_level (d);
2884             }
2885           else
2886             d = pushdecl_with_scope (d, b);
2887
2888           if (ANON_AGGRNAME_P (name))
2889             DECL_IGNORED_P (d) = 1;
2890
2891           TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2892           DECL_ASSEMBLER_NAME (d) = DECL_NAME (d);
2893
2894           /* If this is a local class, keep track of it.  We need this
2895              information for name-mangling, and so that it is possible to find
2896              all function definitions in a translation unit in a convenient
2897              way.  (It's otherwise tricky to find a member function definition
2898              it's only pointed to from within a local class.)  */
2899           if (TYPE_CONTEXT (type)
2900               && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL
2901               && !processing_template_decl)
2902             VARRAY_PUSH_TREE (local_classes, type);
2903
2904           if (!uses_template_parms (type))
2905             {
2906               if (flag_new_abi)
2907                 DECL_ASSEMBLER_NAME (d) = mangle_type (type);
2908               else
2909                 DECL_ASSEMBLER_NAME (d)
2910                   = get_identifier (build_overload_name (type, 1, 1));
2911             }
2912         }
2913       if (b->parm_flag == 2)
2914         {
2915           if (!COMPLETE_TYPE_P (current_class_type))
2916             CLASSTYPE_TAGS (current_class_type) = b->tags;
2917         }
2918     }
2919
2920   if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2921     /* Use the canonical TYPE_DECL for this node.  */
2922     TYPE_STUB_DECL (type) = TYPE_NAME (type);
2923   else
2924     {
2925       /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2926          will be the tagged type we just added to the current
2927          binding level.  This fake NULL-named TYPE_DECL node helps
2928          dwarfout.c to know when it needs to output a
2929          representation of a tagged type, and it also gives us a
2930          convenient place to record the "scope start" address for
2931          the tagged type.  */
2932
2933       tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2934       TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2935     }
2936 }
2937
2938 /* Counter used to create anonymous type names.  */
2939
2940 static int anon_cnt = 0;
2941
2942 /* Return an IDENTIFIER which can be used as a name for
2943    anonymous structs and unions.  */
2944
2945 tree
2946 make_anon_name ()
2947 {
2948   char buf[32];
2949
2950   sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2951   return get_identifier (buf);
2952 }
2953
2954 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2955    This keeps dbxout from getting confused.  */
2956
2957 void
2958 clear_anon_tags ()
2959 {
2960   register struct binding_level *b;
2961   register tree tags;
2962   static int last_cnt = 0;
2963
2964   /* Fast out if no new anon names were declared.  */
2965   if (last_cnt == anon_cnt)
2966     return;
2967
2968   b = current_binding_level;
2969   while (b->tag_transparent)
2970     b = b->level_chain;
2971   tags = b->tags;
2972   while (tags)
2973     {
2974       /* A NULL purpose means we have already processed all tags
2975          from here to the end of the list.  */
2976       if (TREE_PURPOSE (tags) == NULL_TREE)
2977         break;
2978       if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2979         TREE_PURPOSE (tags) = NULL_TREE;
2980       tags = TREE_CHAIN (tags);
2981     }
2982   last_cnt = anon_cnt;
2983 }
2984 \f
2985 /* Subroutine of duplicate_decls: return truthvalue of whether
2986    or not types of these decls match.
2987
2988    For C++, we must compare the parameter list so that `int' can match
2989    `int&' in a parameter position, but `int&' is not confused with
2990    `const int&'.  */
2991
2992 int
2993 decls_match (newdecl, olddecl)
2994      tree newdecl, olddecl;
2995 {
2996   int types_match;
2997
2998   if (newdecl == olddecl)
2999     return 1;
3000
3001   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
3002     /* If the two DECLs are not even the same kind of thing, we're not
3003        interested in their types.  */
3004     return 0;
3005
3006   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3007     {
3008       tree f1 = TREE_TYPE (newdecl);
3009       tree f2 = TREE_TYPE (olddecl);
3010       tree p1 = TYPE_ARG_TYPES (f1);
3011       tree p2 = TYPE_ARG_TYPES (f2);
3012
3013       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
3014           && ! (DECL_EXTERN_C_P (newdecl)
3015                 && DECL_EXTERN_C_P (olddecl)))
3016         return 0;
3017
3018       if (TREE_CODE (f1) != TREE_CODE (f2))
3019         return 0;
3020
3021       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
3022         {
3023           if ((! strict_prototypes_lang_c || DECL_BUILT_IN (olddecl))
3024               && DECL_EXTERN_C_P (olddecl)
3025               && p2 == NULL_TREE)
3026             {
3027               types_match = self_promoting_args_p (p1);
3028               if (p1 == void_list_node)
3029                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
3030             }
3031           else if (!strict_prototypes_lang_c
3032                    && DECL_EXTERN_C_P (olddecl)
3033                    && DECL_EXTERN_C_P (newdecl)
3034                    && p1 == NULL_TREE)
3035             {
3036               types_match = self_promoting_args_p (p2);
3037               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
3038             }
3039           else
3040             types_match = compparms (p1, p2);
3041         }
3042       else
3043         types_match = 0;
3044     }
3045   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3046     {
3047       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3048                                 DECL_TEMPLATE_PARMS (olddecl)))
3049         return 0;
3050
3051       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
3052           != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
3053         return 0;
3054
3055       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3056         types_match = 1;
3057       else
3058         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
3059                                    DECL_TEMPLATE_RESULT (newdecl));
3060     }
3061   else
3062     {
3063       if (TREE_TYPE (newdecl) == error_mark_node)
3064         types_match = TREE_TYPE (olddecl) == error_mark_node;
3065       else if (TREE_TYPE (olddecl) == NULL_TREE)
3066         types_match = TREE_TYPE (newdecl) == NULL_TREE;
3067       else if (TREE_TYPE (newdecl) == NULL_TREE)
3068         types_match = 0;
3069       else
3070         types_match = comptypes (TREE_TYPE (newdecl),
3071                                  TREE_TYPE (olddecl),
3072                                  COMPARE_REDECLARATION);
3073     }
3074
3075   return types_match;
3076 }
3077
3078 /* If NEWDECL is `static' and an `extern' was seen previously,
3079    warn about it.  OLDDECL is the previous declaration.
3080
3081    Note that this does not apply to the C++ case of declaring
3082    a variable `extern const' and then later `const'.
3083
3084    Don't complain about built-in functions, since they are beyond
3085    the user's control.  */
3086
3087 static void
3088 warn_extern_redeclared_static (newdecl, olddecl)
3089      tree newdecl, olddecl;
3090 {
3091   static const char *explicit_extern_static_warning
3092     = "`%D' was declared `extern' and later `static'";
3093   static const char *implicit_extern_static_warning
3094     = "`%D' was declared implicitly `extern' and later `static'";
3095
3096   tree name;
3097
3098   if (TREE_CODE (newdecl) == TYPE_DECL
3099       || TREE_CODE (newdecl) == TEMPLATE_DECL
3100       || TREE_CODE (newdecl) == CONST_DECL)
3101     return;
3102
3103   /* Don't get confused by static member functions; that's a different
3104      use of `static'.  */
3105   if (TREE_CODE (newdecl) == FUNCTION_DECL
3106       && DECL_STATIC_FUNCTION_P (newdecl))
3107     return;
3108
3109   /* If the old declaration was `static', or the new one isn't, then
3110      then everything is OK.  */
3111   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
3112     return;
3113
3114   /* It's OK to declare a builtin function as `static'.  */
3115   if (TREE_CODE (olddecl) == FUNCTION_DECL
3116       && DECL_ARTIFICIAL (olddecl))
3117     return;
3118
3119   name = DECL_ASSEMBLER_NAME (newdecl);
3120   cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
3121               ? implicit_extern_static_warning
3122               : explicit_extern_static_warning, newdecl);
3123   cp_pedwarn_at ("previous declaration of `%D'", olddecl);
3124 }
3125
3126 /* Handle when a new declaration NEWDECL has the same name as an old
3127    one OLDDECL in the same binding contour.  Prints an error message
3128    if appropriate.
3129
3130    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
3131    Otherwise, return 0.  */
3132
3133 int
3134 duplicate_decls (newdecl, olddecl)
3135      tree newdecl, olddecl;
3136 {
3137   unsigned olddecl_uid = DECL_UID (olddecl);
3138   int olddecl_friend = 0, types_match = 0;
3139   int new_defines_function = 0;
3140
3141   if (newdecl == olddecl)
3142     return 1;
3143
3144   types_match = decls_match (newdecl, olddecl);
3145
3146   /* If either the type of the new decl or the type of the old decl is an
3147      error_mark_node, then that implies that we have already issued an
3148      error (earlier) for some bogus type specification, and in that case,
3149      it is rather pointless to harass the user with yet more error message
3150      about the same declaration, so just pretend the types match here.  */
3151   if (TREE_TYPE (newdecl) == error_mark_node
3152       || TREE_TYPE (olddecl) == error_mark_node)
3153     types_match = 1;
3154
3155   /* Check for redeclaration and other discrepancies. */
3156   if (TREE_CODE (olddecl) == FUNCTION_DECL
3157       && DECL_ARTIFICIAL (olddecl))
3158     {
3159       if (TREE_CODE (newdecl) != FUNCTION_DECL)
3160         {
3161           /* If you declare a built-in or predefined function name as static,
3162              the old definition is overridden, but optionally warn this was a
3163              bad choice of name.  */
3164           if (! TREE_PUBLIC (newdecl))
3165             {
3166               if (warn_shadow)
3167                 cp_warning ("shadowing %s function `%#D'",
3168                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3169                             olddecl);
3170               /* Discard the old built-in function.  */
3171               return 0;
3172             }
3173           /* If the built-in is not ansi, then programs can override
3174              it even globally without an error.  */
3175           else if (! DECL_BUILT_IN (olddecl))
3176             cp_warning ("library function `%#D' redeclared as non-function `%#D'",
3177                         olddecl, newdecl);
3178           else
3179             {
3180               cp_error ("declaration of `%#D'", newdecl);
3181               cp_error ("conflicts with built-in declaration `%#D'",
3182                         olddecl);
3183             }
3184           return 0;
3185         }
3186       else if (!types_match)
3187         {
3188           if ((DECL_EXTERN_C_P (newdecl)
3189                && DECL_EXTERN_C_P (olddecl))
3190               || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3191                             TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3192             {
3193               /* A near match; override the builtin.  */
3194
3195               if (TREE_PUBLIC (newdecl))
3196                 {
3197                   cp_warning ("new declaration `%#D'", newdecl);
3198                   cp_warning ("ambiguates built-in declaration `%#D'",
3199                               olddecl);
3200                 }
3201               else if (warn_shadow)
3202                 cp_warning ("shadowing %s function `%#D'",
3203                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3204                             olddecl);
3205             }
3206           else
3207             /* Discard the old built-in function.  */
3208             return 0;
3209         }
3210
3211       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3212         {
3213           /* If a builtin function is redeclared as `static', merge
3214              the declarations, but make the original one static.  */
3215           DECL_THIS_STATIC (olddecl) = 1;
3216           TREE_PUBLIC (olddecl) = 0;
3217
3218           /* Make the old declaration consistent with the new one so
3219              that all remnants of the builtin-ness of this function
3220              will be banished.  */
3221           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3222           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3223           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3224           SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (newdecl),
3225                                        newdecl);
3226         }
3227     }
3228   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3229     {
3230       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3231            && TREE_CODE (newdecl) != TYPE_DECL
3232            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3233                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3234           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3235               && TREE_CODE (olddecl) != TYPE_DECL
3236               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3237                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3238                         == TYPE_DECL))))
3239         {
3240           /* We do nothing special here, because C++ does such nasty
3241              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
3242              get shadowed, and know that if we need to find a TYPE_DECL
3243              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3244              slot of the identifier.  */
3245           return 0;
3246         }
3247
3248       if ((TREE_CODE (newdecl) == FUNCTION_DECL
3249            && DECL_FUNCTION_TEMPLATE_P (olddecl))
3250           || (TREE_CODE (olddecl) == FUNCTION_DECL
3251               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3252         return 0;
3253
3254       cp_error ("`%#D' redeclared as different kind of symbol", newdecl);
3255       if (TREE_CODE (olddecl) == TREE_LIST)
3256         olddecl = TREE_VALUE (olddecl);
3257       cp_error_at ("previous declaration of `%#D'", olddecl);
3258
3259       /* New decl is completely inconsistent with the old one =>
3260          tell caller to replace the old one.  */
3261
3262       return 0;
3263     }
3264   else if (!types_match)
3265     {
3266       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
3267         /* These are certainly not duplicate declarations; they're
3268            from different scopes.  */
3269         return 0;
3270
3271       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3272         {
3273           /* The name of a class template may not be declared to refer to
3274              any other template, class, function, object, namespace, value,
3275              or type in the same scope.  */
3276           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3277               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3278             {
3279               cp_error ("declaration of template `%#D'", newdecl);
3280               cp_error_at ("conflicts with previous declaration `%#D'",
3281                            olddecl);
3282             }
3283           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3284                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3285                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3286                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3287                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3288                                            DECL_TEMPLATE_PARMS (olddecl)))
3289             {
3290               cp_error ("new declaration `%#D'", newdecl);
3291               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3292             }
3293           return 0;
3294         }
3295       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3296         {
3297           if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
3298             {
3299               cp_error ("declaration of C function `%#D' conflicts with",
3300                         newdecl);
3301               cp_error_at ("previous declaration `%#D' here", olddecl);
3302             }
3303           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3304                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3305             {
3306               cp_error ("new declaration `%#D'", newdecl);
3307               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3308             }
3309           else
3310             return 0;
3311         }
3312
3313       /* Already complained about this, so don't do so again.  */
3314       else if (current_class_type == NULL_TREE
3315           || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3316         {
3317           cp_error ("conflicting types for `%#D'", newdecl);
3318           cp_error_at ("previous declaration as `%#D'", olddecl);
3319         }
3320     }
3321   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3322             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3323                  && (!DECL_TEMPLATE_INFO (newdecl)
3324                      || (DECL_TI_TEMPLATE (newdecl)
3325                          != DECL_TI_TEMPLATE (olddecl))))
3326                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3327                     && (!DECL_TEMPLATE_INFO (olddecl)
3328                         || (DECL_TI_TEMPLATE (olddecl)
3329                             != DECL_TI_TEMPLATE (newdecl))))))
3330     /* It's OK to have a template specialization and a non-template
3331        with the same type, or to have specializations of two
3332        different templates with the same type.  Note that if one is a
3333        specialization, and the other is an instantiation of the same
3334        template, that we do not exit at this point.  That situation
3335        can occur if we instantiate a template class, and then
3336        specialize one of its methods.  This situation is legal, but
3337        the declarations must be merged in the usual way.  */
3338     return 0;
3339   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3340            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3341                 && !DECL_USE_TEMPLATE (newdecl))
3342                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3343                    && !DECL_USE_TEMPLATE (olddecl))))
3344     /* One of the declarations is a template instantiation, and the
3345        other is not a template at all.  That's OK.  */
3346     return 0;
3347   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3348            && DECL_NAMESPACE_ALIAS (newdecl)
3349            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3350     /* Redeclaration of namespace alias, ignore it. */
3351     return 1;
3352   else
3353     {
3354       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3355       if (errmsg)
3356         {
3357           cp_error (errmsg, newdecl);
3358           if (DECL_NAME (olddecl) != NULL_TREE)
3359             cp_error_at ((DECL_INITIAL (olddecl)
3360                           && namespace_bindings_p ())
3361                          ? "`%#D' previously defined here"
3362                          : "`%#D' previously declared here", olddecl);
3363         }
3364       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3365                && DECL_INITIAL (olddecl) != NULL_TREE
3366                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3367                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3368         {
3369           /* Prototype decl follows defn w/o prototype.  */
3370           cp_warning_at ("prototype for `%#D'", newdecl);
3371           cp_warning_at ("follows non-prototype definition here", olddecl);
3372         }
3373       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3374                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3375         {
3376           /* extern "C" int foo ();
3377              int foo () { bar (); }
3378              is OK.  */
3379           if (current_lang_stack
3380               == &VARRAY_TREE (current_lang_base, 0))
3381             DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3382           else
3383             {
3384               cp_error_at ("previous declaration of `%#D' with %L linkage",
3385                            olddecl, DECL_LANGUAGE (olddecl));
3386               cp_error ("conflicts with new declaration with %L linkage",
3387                         DECL_LANGUAGE (newdecl));
3388             }
3389         }
3390
3391       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3392         ;
3393       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3394         {
3395           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3396           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3397           int i = 1;
3398
3399           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3400             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3401
3402           for (; t1 && t1 != void_list_node;
3403                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3404             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3405               {
3406                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3407                                            TREE_PURPOSE (t2)))
3408                   {
3409                     if (pedantic)
3410                       {
3411                         cp_pedwarn ("default argument given for parameter %d of `%#D'",
3412                                     i, newdecl);
3413                         cp_pedwarn_at ("after previous specification in `%#D'",
3414                                        olddecl);
3415                       }
3416                   }
3417                 else
3418                   {
3419                     cp_error ("default argument given for parameter %d of `%#D'",
3420                               i, newdecl);
3421                     cp_error_at ("after previous specification in `%#D'",
3422                                  olddecl);
3423                   }
3424               }
3425
3426           if (DECL_THIS_INLINE (newdecl) && ! DECL_THIS_INLINE (olddecl)
3427               && TREE_ADDRESSABLE (olddecl) && warn_inline)
3428             {
3429               cp_warning ("`%#D' was used before it was declared inline",
3430                           newdecl);
3431               cp_warning_at ("previous non-inline declaration here",
3432                              olddecl);
3433             }
3434         }
3435     }
3436
3437   /* If new decl is `static' and an `extern' was seen previously,
3438      warn about it.  */
3439   warn_extern_redeclared_static (newdecl, olddecl);
3440
3441   /* We have committed to returning 1 at this point.  */
3442   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3443     {
3444       /* Now that functions must hold information normally held
3445          by field decls, there is extra work to do so that
3446          declaration information does not get destroyed during
3447          definition.  */
3448       if (DECL_VINDEX (olddecl))
3449         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3450       if (DECL_VIRTUAL_CONTEXT (olddecl))
3451         DECL_VIRTUAL_CONTEXT (newdecl) = DECL_VIRTUAL_CONTEXT (olddecl);
3452       if (DECL_CONTEXT (olddecl))
3453         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3454       if (DECL_PENDING_INLINE_INFO (newdecl) == (struct pending_inline *)0)
3455         DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3456       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3457       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3458       DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3459       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3460       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3461       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3462       DECL_LANG_SPECIFIC (newdecl)->u2 = DECL_LANG_SPECIFIC (olddecl)->u2;
3463       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3464
3465       /* Optionally warn about more than one declaration for the same
3466          name, but don't warn about a function declaration followed by a
3467          definition.  */
3468       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3469           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3470           /* Don't warn about extern decl followed by definition. */
3471           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3472           /* Don't warn about friends, let add_friend take care of it. */
3473           && ! DECL_FRIEND_P (newdecl))
3474         {
3475           cp_warning ("redundant redeclaration of `%D' in same scope", newdecl);
3476           cp_warning_at ("previous declaration of `%D'", olddecl);
3477         }
3478     }
3479
3480   /* Deal with C++: must preserve virtual function table size.  */
3481   if (TREE_CODE (olddecl) == TYPE_DECL)
3482     {
3483       register tree newtype = TREE_TYPE (newdecl);
3484       register tree oldtype = TREE_TYPE (olddecl);
3485
3486       if (newtype != error_mark_node && oldtype != error_mark_node
3487           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3488         {
3489           CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
3490           CLASSTYPE_FRIEND_CLASSES (newtype)
3491             = CLASSTYPE_FRIEND_CLASSES (oldtype);
3492         }
3493
3494       DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
3495     }
3496
3497   /* Copy all the DECL_... slots specified in the new decl
3498      except for any that we copy here from the old type.  */
3499   DECL_MACHINE_ATTRIBUTES (newdecl)
3500     = merge_machine_decl_attributes (olddecl, newdecl);
3501
3502   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3503     {
3504       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3505       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3506         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3507                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3508
3509       return 1;
3510     }
3511
3512   if (types_match)
3513     {
3514       /* Automatically handles default parameters.  */
3515       tree oldtype = TREE_TYPE (olddecl);
3516       tree newtype;
3517
3518       /* Merge the data types specified in the two decls.  */
3519       newtype = common_type (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3520
3521       if (TREE_CODE (newdecl) == VAR_DECL)
3522         DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3523       /* Do this after calling `common_type' so that default
3524          parameters don't confuse us.  */
3525       else if (TREE_CODE (newdecl) == FUNCTION_DECL
3526           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3527               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3528         {
3529           TREE_TYPE (newdecl) = build_exception_variant (newtype,
3530                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3531           TREE_TYPE (olddecl) = build_exception_variant (newtype,
3532                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
3533
3534           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3535               && DECL_SOURCE_LINE (olddecl) != 0
3536               && flag_exceptions
3537               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3538                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3539             {
3540               cp_error ("declaration of `%F' throws different exceptions",
3541                         newdecl);
3542               cp_error_at ("than previous declaration `%F'", olddecl);
3543             }
3544         }
3545       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3546
3547       /* Lay the type out, unless already done.  */
3548       if (! same_type_p (newtype, oldtype)
3549           && TREE_TYPE (newdecl) != error_mark_node
3550           && !(processing_template_decl && uses_template_parms (newdecl)))
3551         layout_type (TREE_TYPE (newdecl));
3552
3553       if ((TREE_CODE (newdecl) == VAR_DECL
3554            || TREE_CODE (newdecl) == PARM_DECL
3555            || TREE_CODE (newdecl) == RESULT_DECL
3556            || TREE_CODE (newdecl) == FIELD_DECL
3557            || TREE_CODE (newdecl) == TYPE_DECL)
3558           && !(processing_template_decl && uses_template_parms (newdecl)))
3559         layout_decl (newdecl, 0);
3560
3561       /* Merge the type qualifiers.  */
3562       if (TREE_READONLY (newdecl))
3563         TREE_READONLY (olddecl) = 1;
3564       if (TREE_THIS_VOLATILE (newdecl))
3565         TREE_THIS_VOLATILE (olddecl) = 1;
3566
3567       /* Merge the initialization information.  */
3568       if (DECL_INITIAL (newdecl) == NULL_TREE
3569           && DECL_INITIAL (olddecl) != NULL_TREE)
3570         {
3571           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3572           DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
3573           DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
3574           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3575               && DECL_LANG_SPECIFIC (newdecl)
3576               && DECL_LANG_SPECIFIC (olddecl))
3577             DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3578         }
3579
3580       /* Merge the section attribute.
3581          We want to issue an error if the sections conflict but that must be
3582          done later in decl_attributes since we are called before attributes
3583          are assigned.  */
3584       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3585         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3586
3587       /* Keep the old rtl since we can safely use it.  */
3588       DECL_RTL (newdecl) = DECL_RTL (olddecl);
3589
3590       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3591         {
3592           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3593             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3594           DECL_NO_CHECK_MEMORY_USAGE (newdecl)
3595             |= DECL_NO_CHECK_MEMORY_USAGE (olddecl);
3596           DECL_NO_LIMIT_STACK (newdecl)
3597             |= DECL_NO_LIMIT_STACK (olddecl);
3598         }
3599     }
3600   /* If cannot merge, then use the new type and qualifiers,
3601      and don't preserve the old rtl.  */
3602   else
3603     {
3604       /* Clean out any memory we had of the old declaration.  */
3605       tree oldstatic = value_member (olddecl, static_aggregates);
3606       if (oldstatic)
3607         TREE_VALUE (oldstatic) = error_mark_node;
3608
3609       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3610       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3611       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3612       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3613     }
3614
3615   /* Merge the storage class information.  */
3616   DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
3617   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3618   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3619   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3620   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3621   if (! DECL_EXTERNAL (olddecl))
3622     DECL_EXTERNAL (newdecl) = 0;
3623
3624   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3625     {
3626       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3627       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3628       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3629       DECL_TEMPLATE_INSTANTIATED (newdecl)
3630         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3631       /* Don't really know how much of the language-specific
3632          values we should copy from old to new.  */
3633       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3634       DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
3635       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3636       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3637       olddecl_friend = DECL_FRIEND_P (olddecl);
3638
3639       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
3640       if (TREE_CODE (newdecl) == FUNCTION_DECL
3641           || DECL_FUNCTION_TEMPLATE_P (newdecl))
3642         DECL_BEFRIENDING_CLASSES (newdecl)
3643           = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3644                      DECL_BEFRIENDING_CLASSES (olddecl));
3645     }
3646
3647   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3648     {
3649       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3650           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3651         {
3652           /* If newdecl is not a specialization, then it is not a
3653              template-related function at all.  And that means that we
3654              shoud have exited above, returning 0.  */
3655           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3656                               0);
3657
3658           if (TREE_USED (olddecl))
3659             /* From [temp.expl.spec]:
3660
3661                If a template, a member template or the member of a class
3662                template is explicitly specialized then that
3663                specialization shall be declared before the first use of
3664                that specialization that would cause an implicit
3665                instantiation to take place, in every translation unit in
3666                which such a use occurs.  */
3667             cp_error ("explicit specialization of %D after first use",
3668                       olddecl);
3669
3670           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3671         }
3672       DECL_THIS_INLINE (newdecl) |= DECL_THIS_INLINE (olddecl);
3673
3674       /* If either decl says `inline', this fn is inline, unless its
3675          definition was passed already.  */
3676       if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3677         DECL_INLINE (olddecl) = 1;
3678       DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3679
3680       if (! types_match)
3681         {
3682           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3683           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3684           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3685         }
3686       if (! types_match || new_defines_function)
3687         {
3688           /* These need to be copied so that the names are available.
3689              Note that if the types do match, we'll preserve inline
3690              info and other bits, but if not, we won't.  */
3691           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3692           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3693         }
3694       if (new_defines_function)
3695         /* If defining a function declared with other language
3696            linkage, use the previously declared language linkage.  */
3697         DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3698       else if (types_match)
3699         {
3700           /* If redeclaring a builtin function, and not a definition,
3701              it stays built in.  */
3702           if (DECL_BUILT_IN (olddecl))
3703             {
3704               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3705               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3706               /* If we're keeping the built-in definition, keep the rtl,
3707                  regardless of declaration matches.  */
3708               DECL_RTL (newdecl) = DECL_RTL (olddecl);
3709             }
3710           else
3711             DECL_FRAME_SIZE (newdecl) = DECL_FRAME_SIZE (olddecl);
3712
3713           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3714           if ((DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl)))
3715             /* Previously saved insns go together with
3716                the function's previous definition.  */
3717             DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3718           /* Don't clear out the arguments if we're redefining a function.  */
3719           if (DECL_ARGUMENTS (olddecl))
3720             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3721         }
3722     }
3723
3724   if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3725     {
3726       NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3727     }
3728
3729   /* Now preserve various other info from the definition.  */
3730   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3731   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3732   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3733   DECL_ASSEMBLER_NAME (newdecl) = DECL_ASSEMBLER_NAME (olddecl);
3734
3735   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3736     {
3737       int function_size;
3738
3739       function_size = sizeof (struct tree_decl);
3740
3741       bcopy ((char *) newdecl + sizeof (struct tree_common),
3742              (char *) olddecl + sizeof (struct tree_common),
3743              function_size - sizeof (struct tree_common));
3744
3745       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3746         {
3747           /* If newdecl is a template instantiation, it is possible that
3748              the following sequence of events has occurred:
3749
3750              o A friend function was declared in a class template.  The
3751              class template was instantiated.
3752
3753              o The instantiation of the friend declaration was
3754              recorded on the instantiation list, and is newdecl.
3755
3756              o Later, however, instantiate_class_template called pushdecl
3757              on the newdecl to perform name injection.  But, pushdecl in
3758              turn called duplicate_decls when it discovered that another
3759              declaration of a global function with the same name already
3760              existed.
3761
3762              o Here, in duplicate_decls, we decided to clobber newdecl.
3763
3764              If we're going to do that, we'd better make sure that
3765              olddecl, and not newdecl, is on the list of
3766              instantiations so that if we try to do the instantiation
3767              again we won't get the clobbered declaration.  */
3768
3769           tree tmpl = DECL_TI_TEMPLATE (newdecl);
3770           tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3771
3772           for (; decls; decls = TREE_CHAIN (decls))
3773             if (TREE_VALUE (decls) == newdecl)
3774               TREE_VALUE (decls) = olddecl;
3775         }
3776     }
3777   else
3778     {
3779       bcopy ((char *) newdecl + sizeof (struct tree_common),
3780              (char *) olddecl + sizeof (struct tree_common),
3781              sizeof (struct tree_decl) - sizeof (struct tree_common)
3782              + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
3783     }
3784
3785   DECL_UID (olddecl) = olddecl_uid;
3786   if (olddecl_friend)
3787     DECL_FRIEND_P (olddecl) = 1;
3788
3789   /* NEWDECL contains the merged attribute lists.
3790      Update OLDDECL to be the same.  */
3791   DECL_MACHINE_ATTRIBUTES (olddecl) = DECL_MACHINE_ATTRIBUTES (newdecl);
3792
3793   return 1;
3794 }
3795
3796 /* Record a decl-node X as belonging to the current lexical scope.
3797    Check for errors (such as an incompatible declaration for the same
3798    name already seen in the same scope).
3799
3800    Returns either X or an old decl for the same name.
3801    If an old decl is returned, it may have been smashed
3802    to agree with what X says.  */
3803
3804 tree
3805 pushdecl (x)
3806      tree x;
3807 {
3808   register tree t;
3809   register tree name;
3810   int need_new_binding;
3811
3812   /* We shouldn't be calling pushdecl when we're generating RTL for a
3813      function that we already did semantic analysis on previously.  */
3814   my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3815                       19990913);
3816
3817   need_new_binding = 1;
3818
3819   if (DECL_TEMPLATE_PARM_P (x))
3820     /* Template parameters have no context; they are not X::T even
3821        when declared within a class or namespace.  */
3822     ;
3823   else
3824     {
3825       if (current_function_decl && x != current_function_decl
3826           /* A local declaration for a function doesn't constitute
3827              nesting.  */
3828           && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3829           /* A local declaration for an `extern' variable is in the
3830              scoped of the current namespace, not the current
3831              function.  */
3832           && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3833           && !DECL_CONTEXT (x))
3834         DECL_CONTEXT (x) = current_function_decl;
3835
3836       /* If this is the declaration for a namespace-scope function,
3837          but the declaration itself is in a local scope, mark the
3838          declaration.  */
3839       if (TREE_CODE (x) == FUNCTION_DECL
3840           && DECL_NAMESPACE_SCOPE_P (x)
3841           && current_function_decl
3842           && x != current_function_decl)
3843         DECL_LOCAL_FUNCTION_P (x) = 1;
3844     }
3845
3846   name = DECL_NAME (x);
3847   if (name)
3848     {
3849 #if 0
3850       /* Not needed...see below.  */
3851       char *file;
3852       int line;
3853 #endif
3854       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3855         name = TREE_OPERAND (name, 0);
3856
3857       /* Namespace-scoped variables are not found in the current level. */
3858       if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x))
3859         t = namespace_binding (name, DECL_CONTEXT (x));
3860       else
3861         t = lookup_name_current_level (name);
3862
3863       /* If we are declaring a function, and the result of name-lookup
3864          was an OVERLOAD, look for an overloaded instance that is
3865          actually the same as the function we are declaring.  (If
3866          there is one, we have to merge our declaration with the
3867          previous declaration.)  */
3868       if (t && TREE_CODE (t) == OVERLOAD)
3869         {
3870           tree match;
3871
3872           if (TREE_CODE (x) == FUNCTION_DECL)
3873             for (match = t; match; match = OVL_NEXT (match))
3874               {
3875                 if (DECL_ASSEMBLER_NAME (OVL_CURRENT (t))
3876                     == DECL_ASSEMBLER_NAME (x))
3877                   break;
3878               }
3879           else
3880             /* Just choose one.  */
3881             match = t;
3882
3883           if (match)
3884             t = OVL_CURRENT (match);
3885           else
3886             t = NULL_TREE;
3887         }
3888
3889       if (t == error_mark_node)
3890         {
3891           /* error_mark_node is 0 for a while during initialization!  */
3892           t = NULL_TREE;
3893           cp_error_at ("`%#D' used prior to declaration", x);
3894         }
3895       else if (t != NULL_TREE)
3896         {
3897           if (TREE_CODE (t) == PARM_DECL)
3898             {
3899               if (DECL_CONTEXT (t) == NULL_TREE)
3900                 fatal ("parse errors have confused me too much");
3901
3902               /* Check for duplicate params.  */
3903               if (duplicate_decls (x, t))
3904                 return t;
3905             }
3906           else if ((DECL_EXTERN_C_FUNCTION_P (x)
3907                     || DECL_FUNCTION_TEMPLATE_P (x))
3908                    && is_overloaded_fn (t))
3909             /* Don't do anything just yet. */;
3910           else if (t == wchar_decl_node)
3911             {
3912               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3913                 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x));
3914
3915               /* Throw away the redeclaration.  */
3916               return t;
3917             }
3918           else if (TREE_CODE (t) != TREE_CODE (x))
3919             {
3920               if (duplicate_decls (x, t))
3921                 return t;
3922             }
3923           else if (duplicate_decls (x, t))
3924             {
3925               if (TREE_CODE (t) == TYPE_DECL)
3926                 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3927               else if (TREE_CODE (t) == FUNCTION_DECL)
3928                 check_default_args (t);
3929
3930               return t;
3931             }
3932           else if (DECL_MAIN_P (x))
3933             {
3934               /* A redeclaration of main, but not a duplicate of the
3935                  previous one.
3936
3937                  [basic.start.main]
3938
3939                  This function shall not be overloaded.  */
3940               cp_error_at ("invalid redeclaration of `%D'", t);
3941               cp_error ("as `%D'", x);
3942               /* We don't try to push this declaration since that
3943                  causes a crash.  */
3944               return x;
3945             }
3946         }
3947
3948       check_template_shadow (x);
3949
3950       /* If this is a function conjured up by the backend, massage it
3951          so it looks friendly.  */
3952       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
3953         {
3954           retrofit_lang_decl (x);
3955           DECL_LANGUAGE (x) = lang_c;
3956         }
3957
3958       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
3959         {
3960           t = push_overloaded_decl (x, PUSH_LOCAL);
3961           if (t != x)
3962             return t;
3963           if (!namespace_bindings_p ())
3964             /* We do not need to create a binding for this name;
3965                push_overloaded_decl will have already done so if
3966                necessary.  */
3967             need_new_binding = 0;
3968         }
3969       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
3970         {
3971           t = push_overloaded_decl (x, PUSH_GLOBAL);
3972           if (t == x)
3973             add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
3974           return t;
3975         }
3976
3977       /* If declaring a type as a typedef, copy the type (unless we're
3978          at line 0), and install this TYPE_DECL as the new type's typedef
3979          name.  See the extensive comment in ../c-decl.c (pushdecl). */
3980       if (TREE_CODE (x) == TYPE_DECL)
3981         {
3982           tree type = TREE_TYPE (x);
3983           if (DECL_SOURCE_LINE (x) == 0)
3984             {
3985               if (TYPE_NAME (type) == 0)
3986                 TYPE_NAME (type) = x;
3987             }
3988           else if (type != error_mark_node && TYPE_NAME (type) != x
3989                    /* We don't want to copy the type when all we're
3990                       doing is making a TYPE_DECL for the purposes of
3991                       inlining.  */
3992                    && (!TYPE_NAME (type)
3993                        || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
3994             {
3995               DECL_ORIGINAL_TYPE (x) = type;
3996               type = build_type_copy (type);
3997               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
3998               TYPE_NAME (type) = x;
3999               TREE_TYPE (x) = type;
4000             }
4001
4002           if (type != error_mark_node
4003               && TYPE_NAME (type)
4004               && TYPE_IDENTIFIER (type))
4005             set_identifier_type_value_with_scope (DECL_NAME (x), type,
4006                                                   current_binding_level);
4007
4008         }
4009
4010       /* Multiple external decls of the same identifier ought to match.
4011
4012          We get warnings about inline functions where they are defined.
4013          We get warnings about other functions from push_overloaded_decl.
4014
4015          Avoid duplicate warnings where they are used.  */
4016       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
4017         {
4018           tree decl;
4019
4020           decl = IDENTIFIER_NAMESPACE_VALUE (name);
4021           if (decl && TREE_CODE (decl) == OVERLOAD)
4022             decl = OVL_FUNCTION (decl);
4023
4024           if (decl && decl != error_mark_node
4025               && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
4026               /* If different sort of thing, we already gave an error.  */
4027               && TREE_CODE (decl) == TREE_CODE (x)
4028               && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
4029             {
4030               cp_pedwarn ("type mismatch with previous external decl", x);
4031               cp_pedwarn_at ("previous external decl of `%#D'", decl);
4032             }
4033         }
4034
4035       /* This name is new in its binding level.
4036          Install the new declaration and return it.  */
4037       if (namespace_bindings_p ())
4038         {
4039           /* Install a global value.  */
4040
4041           /* If the first global decl has external linkage,
4042              warn if we later see static one.  */
4043           if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
4044             TREE_PUBLIC (name) = 1;
4045
4046           /* Bind the mangled name for the entity.  In the future, we
4047              should not need to do this; mangled names are an
4048              implementation detail of which the front-end should not
4049              need to be aware.  */
4050           if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
4051                 && t != NULL_TREE)
4052               /* For an ordinary function, we create a binding from
4053                  the mangled name (i.e., NAME) to the DECL.  But, for
4054                  an `extern "C"' function, the mangled name and the
4055                  ordinary name are the same so we need not do this.  */
4056               && !DECL_EXTERN_C_FUNCTION_P (x))
4057             {
4058               tree mangled_name;
4059
4060               if (TREE_CODE (x) == TYPE_DECL || TREE_CODE (x) == VAR_DECL
4061                   || TREE_CODE (x) == NAMESPACE_DECL)
4062                 mangled_name = name;
4063               else
4064                 mangled_name = DECL_ASSEMBLER_NAME (x);
4065
4066               if (TREE_CODE (x) == FUNCTION_DECL)
4067                 my_friendly_assert
4068                   ((IDENTIFIER_GLOBAL_VALUE (mangled_name) == NULL_TREE)
4069                   || (IDENTIFIER_GLOBAL_VALUE (mangled_name) == x), 378);
4070               SET_IDENTIFIER_NAMESPACE_VALUE (mangled_name, x);
4071             }
4072
4073           /* Don't forget if the function was used via an implicit decl.  */
4074           if (IDENTIFIER_IMPLICIT_DECL (name)
4075               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
4076             TREE_USED (x) = 1;
4077
4078           /* Don't forget if its address was taken in that way.  */
4079           if (IDENTIFIER_IMPLICIT_DECL (name)
4080               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
4081             TREE_ADDRESSABLE (x) = 1;
4082
4083           /* Warn about mismatches against previous implicit decl.  */
4084           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
4085               /* If this real decl matches the implicit, don't complain.  */
4086               && ! (TREE_CODE (x) == FUNCTION_DECL
4087                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
4088             cp_warning
4089               ("`%D' was previously implicitly declared to return `int'", x);
4090
4091           /* If new decl is `static' and an `extern' was seen previously,
4092              warn about it.  */
4093           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
4094             warn_extern_redeclared_static (x, t);
4095         }
4096       else
4097         {
4098           /* Here to install a non-global value.  */
4099           tree oldlocal = IDENTIFIER_VALUE (name);
4100           tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
4101
4102           if (need_new_binding)
4103             {
4104               push_local_binding (name, x, 0);
4105               /* Because push_local_binding will hook X on to the
4106                  current_binding_level's name list, we don't want to
4107                  do that again below.  */
4108               need_new_binding = 0;
4109             }
4110
4111           /* If this is a TYPE_DECL, push it into the type value slot.  */
4112           if (TREE_CODE (x) == TYPE_DECL)
4113             set_identifier_type_value_with_scope (name, TREE_TYPE (x),
4114                                                   current_binding_level);
4115
4116           /* Clear out any TYPE_DECL shadowed by a namespace so that
4117              we won't think this is a type.  The C struct hack doesn't
4118              go through namespaces.  */
4119           if (TREE_CODE (x) == NAMESPACE_DECL)
4120             set_identifier_type_value_with_scope (name, NULL_TREE,
4121                                                   current_binding_level);
4122
4123           if (oldlocal)
4124             {
4125               tree d = oldlocal;
4126
4127               while (oldlocal
4128                      && TREE_CODE (oldlocal) == VAR_DECL
4129                      && DECL_DEAD_FOR_LOCAL (oldlocal))
4130                 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
4131
4132               if (oldlocal == NULL_TREE)
4133                 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
4134             }
4135
4136           /* If this is an extern function declaration, see if we
4137              have a global definition or declaration for the function.  */
4138           if (oldlocal == NULL_TREE
4139               && DECL_EXTERNAL (x)
4140               && oldglobal != NULL_TREE
4141               && TREE_CODE (x) == FUNCTION_DECL
4142               && TREE_CODE (oldglobal) == FUNCTION_DECL)
4143             {
4144               /* We have one.  Their types must agree.  */
4145               if (decls_match (x, oldglobal))
4146                 /* OK */;
4147               else
4148                 {
4149                   cp_warning ("extern declaration of `%#D' doesn't match", x);
4150                   cp_warning_at ("global declaration `%#D'", oldglobal);
4151                 }
4152             }
4153           /* If we have a local external declaration,
4154              and no file-scope declaration has yet been seen,
4155              then if we later have a file-scope decl it must not be static.  */
4156           if (oldlocal == NULL_TREE
4157               && oldglobal == NULL_TREE
4158               && DECL_EXTERNAL (x)
4159               && TREE_PUBLIC (x))
4160             TREE_PUBLIC (name) = 1;
4161
4162           /* Warn if shadowing an argument at the top level of the body.  */
4163           if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
4164               /* Inline decls shadow nothing.  */
4165               && !DECL_FROM_INLINE (x)
4166               && TREE_CODE (oldlocal) == PARM_DECL
4167               /* Don't complain if it's from an enclosing function.  */
4168               && DECL_CONTEXT (oldlocal) == current_function_decl
4169               && TREE_CODE (x) != PARM_DECL)
4170             {
4171               /* Go to where the parms should be and see if we
4172                  find them there.  */
4173               struct binding_level *b = current_binding_level->level_chain;
4174
4175               if (cleanup_label)
4176                 b = b->level_chain;
4177
4178               /* ARM $8.3 */
4179               if (b->parm_flag == 1)
4180                 cp_error ("declaration of `%#D' shadows a parameter", name);
4181             }
4182
4183           /* Maybe warn if shadowing something else.  */
4184           if (warn_shadow && !DECL_EXTERNAL (x)
4185               /* Inline decls shadow nothing.  */
4186               && !DECL_FROM_INLINE (x)
4187               /* No shadow warnings for internally generated vars.  */
4188               && ! DECL_ARTIFICIAL (x)
4189               /* No shadow warnings for vars made for inlining.  */
4190               && ! DECL_FROM_INLINE (x))
4191             {
4192               if (oldlocal != NULL_TREE && TREE_CODE (oldlocal) == PARM_DECL)
4193                 warning ("declaration of `%s' shadows a parameter",
4194                         IDENTIFIER_POINTER (name));
4195               else if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4196                        && current_class_ptr
4197                        && !TREE_STATIC (name))
4198                 warning ("declaration of `%s' shadows a member of `this'",
4199                         IDENTIFIER_POINTER (name));
4200               else if (oldlocal != NULL_TREE)
4201                 warning ("declaration of `%s' shadows previous local",
4202                         IDENTIFIER_POINTER (name));
4203               else if (oldglobal != NULL_TREE)
4204                 /* XXX shadow warnings in outer-more namespaces */
4205                 warning ("declaration of `%s' shadows global declaration",
4206                         IDENTIFIER_POINTER (name));
4207             }
4208         }
4209
4210       if (TREE_CODE (x) == FUNCTION_DECL)
4211         check_default_args (x);
4212
4213       /* Keep count of variables in this level with incomplete type.  */
4214       if (TREE_CODE (x) == VAR_DECL
4215           && TREE_TYPE (x) != error_mark_node
4216           && ((!COMPLETE_TYPE_P (TREE_TYPE (x))
4217                && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
4218               /* RTTI TD entries are created while defining the type_info.  */
4219               || (TYPE_LANG_SPECIFIC (TREE_TYPE (x))
4220                   && TYPE_BEING_DEFINED (TREE_TYPE (x)))))
4221         {
4222           if (namespace_bindings_p ())
4223             namespace_scope_incomplete
4224               = tree_cons (NULL_TREE, x, namespace_scope_incomplete);
4225           else
4226             current_binding_level->incomplete
4227               = tree_cons (NULL_TREE, x, current_binding_level->incomplete);
4228         }
4229     }
4230
4231   if (need_new_binding)
4232     add_decl_to_level (x,
4233                        DECL_NAMESPACE_SCOPE_P (x)
4234                        ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4235                        : current_binding_level);
4236
4237   return x;
4238 }
4239
4240 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
4241    caller to set DECL_CONTEXT properly.  */
4242
4243 static tree
4244 pushdecl_with_scope (x, level)
4245      tree x;
4246      struct binding_level *level;
4247 {
4248   register struct binding_level *b;
4249   tree function_decl = current_function_decl;
4250
4251   current_function_decl = NULL_TREE;
4252   if (level->parm_flag == 2)
4253     {
4254       b = class_binding_level;
4255       class_binding_level = level;
4256       pushdecl_class_level (x);
4257       class_binding_level = b;
4258     }
4259   else
4260     {
4261       b = current_binding_level;
4262       current_binding_level = level;
4263       x = pushdecl (x);
4264       current_binding_level = b;
4265     }
4266   current_function_decl = function_decl;
4267   return x;
4268 }
4269
4270 /* Like pushdecl, only it places X in the current namespace,
4271    if appropriate.  */
4272
4273 tree
4274 pushdecl_namespace_level (x)
4275      tree x;
4276 {
4277   register struct binding_level *b = current_binding_level;
4278   register tree t;
4279
4280   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4281
4282   /* Now, the type_shadowed stack may screw us.  Munge it so it does
4283      what we want.  */
4284   if (TREE_CODE (x) == TYPE_DECL)
4285     {
4286       tree name = DECL_NAME (x);
4287       tree newval;
4288       tree *ptr = (tree *)0;
4289       for (; b != global_binding_level; b = b->level_chain)
4290         {
4291           tree shadowed = b->type_shadowed;
4292           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4293             if (TREE_PURPOSE (shadowed) == name)
4294               {
4295                 ptr = &TREE_VALUE (shadowed);
4296                 /* Can't break out of the loop here because sometimes
4297                    a binding level will have duplicate bindings for
4298                    PT names.  It's gross, but I haven't time to fix it.  */
4299               }
4300         }
4301       newval = TREE_TYPE (x);
4302       if (ptr == (tree *)0)
4303         {
4304           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
4305              up here if this is changed to an assertion.  --KR  */
4306           SET_IDENTIFIER_TYPE_VALUE (name, newval);
4307         }
4308       else
4309         {
4310           *ptr = newval;
4311         }
4312     }
4313   return t;
4314 }
4315
4316 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4317    if appropriate.  */
4318
4319 tree
4320 pushdecl_top_level (x)
4321      tree x;
4322 {
4323   push_to_top_level ();
4324   x = pushdecl_namespace_level (x);
4325   pop_from_top_level ();
4326   return x;
4327 }
4328
4329 /* Make the declaration of X appear in CLASS scope.  */
4330
4331 void
4332 pushdecl_class_level (x)
4333      tree x;
4334 {
4335   /* Don't use DECL_ASSEMBLER_NAME here!  Everything that looks in class
4336      scope looks for the pre-mangled name.  */
4337   register tree name;
4338
4339   if (TREE_CODE (x) == OVERLOAD)
4340     x = OVL_CURRENT (x);
4341   name = DECL_NAME (x);
4342
4343   if (name)
4344     {
4345       push_class_level_binding (name, x);
4346       if (TREE_CODE (x) == TYPE_DECL)
4347         set_identifier_type_value (name, TREE_TYPE (x));
4348     }
4349   else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4350     {
4351       tree f;
4352
4353       for (f = TYPE_FIELDS (TREE_TYPE (x));
4354            f;
4355            f = TREE_CHAIN (f))
4356         pushdecl_class_level (f);
4357     }
4358 }
4359
4360 /* Enter DECL into the symbol table, if that's appropriate.  Returns
4361    DECL, or a modified version thereof.  */
4362
4363 tree
4364 maybe_push_decl (decl)
4365      tree decl;
4366 {
4367   tree type = TREE_TYPE (decl);
4368
4369   /* Add this decl to the current binding level, but not if it comes
4370      from another scope, e.g. a static member variable.  TEM may equal
4371      DECL or it may be a previous decl of the same name.  */
4372   if (decl == error_mark_node
4373       || (TREE_CODE (decl) != PARM_DECL
4374           && DECL_CONTEXT (decl) != NULL_TREE
4375           /* Definitions of namespace members outside their namespace are
4376              possible. */
4377           && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4378       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4379       || TREE_CODE (type) == UNKNOWN_TYPE
4380       /* The declaration of a template specialization does not affect
4381          the functions available for overload resolution, so we do not
4382          call pushdecl.  */
4383       || (TREE_CODE (decl) == FUNCTION_DECL
4384           && DECL_TEMPLATE_SPECIALIZATION (decl)))
4385     return decl;
4386   else
4387     return pushdecl (decl);
4388 }
4389
4390 /* Make the declaration(s) of X appear in CLASS scope
4391    under the name NAME.  */
4392
4393 void
4394 push_class_level_binding (name, x)
4395      tree name;
4396      tree x;
4397 {
4398   tree binding;
4399   /* The class_binding_level will be NULL if x is a template
4400      parameter name in a member template.  */
4401   if (!class_binding_level)
4402     return;
4403
4404   /* Make sure that this new member does not have the same name
4405      as a template parameter.  */
4406   if (TYPE_BEING_DEFINED (current_class_type))
4407     check_template_shadow (x);
4408
4409   /* If this declaration shadows a declaration from an enclosing
4410      class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4411      we leave this class.  Record the shadowed declaration here.  */
4412   binding = IDENTIFIER_BINDING (name);
4413   if (binding
4414       && ((TREE_CODE (x) == OVERLOAD
4415            && BINDING_VALUE (binding)
4416            && is_overloaded_fn (BINDING_VALUE (binding)))
4417           || INHERITED_VALUE_BINDING_P (binding)))
4418     {
4419       tree shadow;
4420       tree old_decl;
4421
4422       /* If the old binding was from a base class, and was for a tag
4423          name, slide it over to make room for the new binding.  The
4424          old binding is still visible if explicitly qualified with a
4425          class-key.  */
4426       if (INHERITED_VALUE_BINDING_P (binding)
4427           && BINDING_VALUE (binding)
4428           && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4429           && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4430           && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4431         {
4432           old_decl = BINDING_TYPE (binding);
4433           BINDING_TYPE (binding) = BINDING_VALUE (binding);
4434           BINDING_VALUE (binding) = NULL_TREE;
4435           INHERITED_VALUE_BINDING_P (binding) = 0;
4436         }
4437       else
4438         old_decl = BINDING_VALUE (binding);
4439
4440       /* There was already a binding for X containing fewer
4441          functions than are named in X.  Find the previous
4442          declaration of X on the class-shadowed list, and update it.  */
4443       for (shadow = class_binding_level->class_shadowed;
4444            shadow;
4445            shadow = TREE_CHAIN (shadow))
4446         if (TREE_PURPOSE (shadow) == name
4447             && TREE_TYPE (shadow) == old_decl)
4448           {
4449             BINDING_VALUE (binding) = x;
4450             INHERITED_VALUE_BINDING_P (binding) = 0;
4451             TREE_TYPE (shadow) = x;
4452             return;
4453           }
4454     }
4455
4456   /* If we didn't replace an existing binding, put the binding on the
4457      stack of bindings for the identifier, and update
4458      IDENTIFIER_CLASS_VALUE.  */
4459   if (push_class_binding (name, x))
4460     {
4461       class_binding_level->class_shadowed
4462         = tree_cons (name, IDENTIFIER_CLASS_VALUE (name),
4463                      class_binding_level->class_shadowed);
4464       /* Record the value we are binding NAME to so that we can know
4465          what to pop later.  */
4466       TREE_TYPE (class_binding_level->class_shadowed) = x;
4467     }
4468 }
4469
4470 /* Insert another USING_DECL into the current binding level, returning
4471    this declaration. If this is a redeclaration, do nothing, and
4472    return NULL_TREE if this not in namespace scope (in namespace
4473    scope, a using decl might extend any previous bindings).  */
4474
4475 tree
4476 push_using_decl (scope, name)
4477      tree scope;
4478      tree name;
4479 {
4480   tree decl;
4481
4482   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4483   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4484   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4485     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4486       break;
4487   if (decl)
4488     return namespace_bindings_p () ? decl : NULL_TREE;
4489   decl = build_lang_decl (USING_DECL, name, void_type_node);
4490   DECL_INITIAL (decl) = scope;
4491   TREE_CHAIN (decl) = current_binding_level->usings;
4492   current_binding_level->usings = decl;
4493   return decl;
4494 }
4495
4496 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4497    changed (i.e. there was already a directive), or the fresh
4498    TREE_LIST otherwise.  */
4499
4500 tree
4501 push_using_directive (used)
4502      tree used;
4503 {
4504   tree ud = current_binding_level->using_directives;
4505   tree iter, ancestor;
4506
4507   /* Check if we already have this. */
4508   if (purpose_member (used, ud) != NULL_TREE)
4509     return NULL_TREE;
4510
4511   /* Recursively add all namespaces used. */
4512   for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4513     push_using_directive (TREE_PURPOSE (iter));
4514
4515   ancestor = namespace_ancestor (current_decl_namespace (), used);
4516   ud = current_binding_level->using_directives;
4517   ud = tree_cons (used, ancestor, ud);
4518   current_binding_level->using_directives = ud;
4519   return ud;
4520 }
4521
4522 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4523    other definitions already in place.  We get around this by making
4524    the value of the identifier point to a list of all the things that
4525    want to be referenced by that name.  It is then up to the users of
4526    that name to decide what to do with that list.
4527
4528    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
4529    DECL_TEMPLATE_RESULT.  It is dealt with the same way.
4530
4531    FLAGS is a bitwise-or of the following values:
4532      PUSH_LOCAL: Bind DECL in the current scope, rather than at
4533                  namespace scope.
4534      PUSH_USING: DECL is being pushed as the result of a using
4535                  declaration.
4536
4537    The value returned may be a previous declaration if we guessed wrong
4538    about what language DECL should belong to (C or C++).  Otherwise,
4539    it's always DECL (and never something that's not a _DECL).  */
4540
4541 tree
4542 push_overloaded_decl (decl, flags)
4543      tree decl;
4544      int flags;
4545 {
4546   tree name = DECL_NAME (decl);
4547   tree old;
4548   tree new_binding;
4549   int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4550
4551   if (doing_global)
4552     old = namespace_binding (name, DECL_CONTEXT (decl));
4553   else
4554     old = lookup_name_current_level (name);
4555
4556   if (old)
4557     {
4558       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4559         {
4560           tree t = TREE_TYPE (old);
4561           if (IS_AGGR_TYPE (t) && warn_shadow
4562               && (! DECL_IN_SYSTEM_HEADER (decl)
4563                   || ! DECL_IN_SYSTEM_HEADER (old)))
4564             cp_warning ("`%#D' hides constructor for `%#T'", decl, t);
4565           old = NULL_TREE;
4566         }
4567       else if (is_overloaded_fn (old))
4568         {
4569           tree tmp;
4570
4571           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4572             {
4573               tree fn = OVL_CURRENT (tmp);
4574
4575               if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4576                   && !(flags & PUSH_USING)
4577                   && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4578                                 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4579                 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4580                           decl, fn);
4581
4582               if (duplicate_decls (decl, fn))
4583                 return fn;
4584             }
4585         }
4586       else if (old == error_mark_node)
4587         /* Ignore the undefined symbol marker.  */
4588         old = NULL_TREE;
4589       else
4590         {
4591           cp_error_at ("previous non-function declaration `%#D'", old);
4592           cp_error ("conflicts with function declaration `%#D'", decl);
4593           return decl;
4594         }
4595     }
4596
4597   if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4598     {
4599       if (old && TREE_CODE (old) != OVERLOAD)
4600         new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4601       else
4602         new_binding = ovl_cons (decl, old);
4603       if (flags & PUSH_USING)
4604         OVL_USED (new_binding) = 1;
4605     }
4606   else
4607     /* NAME is not ambiguous.  */
4608     new_binding = decl;
4609
4610   if (doing_global)
4611     set_namespace_binding (name, current_namespace, new_binding);
4612   else
4613     {
4614       /* We only create an OVERLOAD if there was a previous binding at
4615          this level, or if decl is a template. In the former case, we
4616          need to remove the old binding and replace it with the new
4617          binding.  We must also run through the NAMES on the binding
4618          level where the name was bound to update the chain.  */
4619
4620       if (TREE_CODE (new_binding) == OVERLOAD && old)
4621         {
4622           tree *d;
4623
4624           for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4625                *d;
4626                d = &TREE_CHAIN (*d))
4627             if (*d == old
4628                 || (TREE_CODE (*d) == TREE_LIST
4629                     && TREE_VALUE (*d) == old))
4630               {
4631                 if (TREE_CODE (*d) == TREE_LIST)
4632                   /* Just replace the old binding with the new.  */
4633                   TREE_VALUE (*d) = new_binding;
4634                 else
4635                   /* Build a TREE_LIST to wrap the OVERLOAD.  */
4636                   *d = tree_cons (NULL_TREE, new_binding,
4637                                   TREE_CHAIN (*d));
4638
4639                 /* And update the CPLUS_BINDING node.  */
4640                 BINDING_VALUE (IDENTIFIER_BINDING (name))
4641                   = new_binding;
4642                 return decl;
4643               }
4644
4645           /* We should always find a previous binding in this case.  */
4646           my_friendly_abort (0);
4647         }
4648
4649       /* Install the new binding.  */
4650       push_local_binding (name, new_binding, flags);
4651     }
4652
4653   return decl;
4654 }
4655 \f
4656 /* Generate an implicit declaration for identifier FUNCTIONID
4657    as a function of type int ().  Print a warning if appropriate.  */
4658
4659 tree
4660 implicitly_declare (functionid)
4661      tree functionid;
4662 {
4663   register tree decl;
4664
4665   /* We used to reuse an old implicit decl here,
4666      but this loses with inline functions because it can clobber
4667      the saved decl chains.  */
4668   decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4669
4670   DECL_EXTERNAL (decl) = 1;
4671   TREE_PUBLIC (decl) = 1;
4672
4673   /* ISO standard says implicit declarations are in the innermost block.
4674      So we record the decl in the standard fashion.  */
4675   pushdecl (decl);
4676   rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
4677
4678   if (warn_implicit
4679       /* Only one warning per identifier.  */
4680       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4681     {
4682       cp_pedwarn ("implicit declaration of function `%#D'", decl);
4683     }
4684
4685   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4686
4687   return decl;
4688 }
4689
4690 /* Return zero if the declaration NEWDECL is valid
4691    when the declaration OLDDECL (assumed to be for the same name)
4692    has already been seen.
4693    Otherwise return an error message format string with a %s
4694    where the identifier should go.  */
4695
4696 static const char *
4697 redeclaration_error_message (newdecl, olddecl)
4698      tree newdecl, olddecl;
4699 {
4700   if (TREE_CODE (newdecl) == TYPE_DECL)
4701     {
4702       /* Because C++ can put things into name space for free,
4703          constructs like "typedef struct foo { ... } foo"
4704          would look like an erroneous redeclaration.  */
4705       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4706         return 0;
4707       else
4708         return "redefinition of `%#D'";
4709     }
4710   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4711     {
4712       /* If this is a pure function, its olddecl will actually be
4713          the original initialization to `0' (which we force to call
4714          abort()).  Don't complain about redefinition in this case.  */
4715       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4716         return 0;
4717
4718       /* If both functions come from different namespaces, this is not
4719          a redeclaration - this is a conflict with a used function. */
4720       if (DECL_NAMESPACE_SCOPE_P (olddecl)
4721           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4722         return "`%D' conflicts with used function";
4723
4724       /* We'll complain about linkage mismatches in
4725          warn_extern_redeclared_static.  */
4726
4727       /* Defining the same name twice is no good.  */
4728       if (DECL_INITIAL (olddecl) != NULL_TREE
4729           && DECL_INITIAL (newdecl) != NULL_TREE)
4730         {
4731           if (DECL_NAME (olddecl) == NULL_TREE)
4732             return "`%#D' not declared in class";
4733           else
4734             return "redefinition of `%#D'";
4735         }
4736       return 0;
4737     }
4738   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4739     {
4740       if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4741            && (DECL_TEMPLATE_RESULT (newdecl)
4742                != DECL_TEMPLATE_RESULT (olddecl))
4743            && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4744            && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4745           || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4746               && COMPLETE_TYPE_P (TREE_TYPE (newdecl))
4747               && COMPLETE_TYPE_P (TREE_TYPE (olddecl))))
4748         return "redefinition of `%#D'";
4749       return 0;
4750     }
4751   else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
4752     {
4753       /* Objects declared at top level:  */
4754       /* If at least one is a reference, it's ok.  */
4755       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4756         return 0;
4757       /* Reject two definitions.  */
4758       return "redefinition of `%#D'";
4759     }
4760   else
4761     {
4762       /* Objects declared with block scope:  */
4763       /* Reject two definitions, and reject a definition
4764          together with an external reference.  */
4765       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4766         return "redeclaration of `%#D'";
4767       return 0;
4768     }
4769 }
4770 \f
4771 /* Create a new label, named ID.  */
4772
4773 static tree
4774 make_label_decl (id, local_p)
4775      tree id;
4776      int local_p;
4777 {
4778   tree decl;
4779
4780   decl = build_decl (LABEL_DECL, id, void_type_node);
4781   if (expanding_p)
4782     /* Make sure every label has an rtx.  */
4783     label_rtx (decl);
4784
4785   DECL_CONTEXT (decl) = current_function_decl;
4786   DECL_MODE (decl) = VOIDmode;
4787   C_DECLARED_LABEL_FLAG (decl) = local_p;
4788
4789   /* Say where one reference is to the label, for the sake of the
4790      error if it is not defined.  */
4791   DECL_SOURCE_LINE (decl) = lineno;
4792   DECL_SOURCE_FILE (decl) = input_filename;
4793
4794   /* Record the fact that this identifier is bound to this label.  */
4795   SET_IDENTIFIER_LABEL_VALUE (id, decl);
4796
4797   return decl;
4798 }
4799
4800 /* Record this label on the list of used labels so that we can check
4801    at the end of the function to see whether or not the label was
4802    actually defined, and so we can check when the label is defined whether
4803    this use is valid.  */
4804
4805 static void
4806 use_label (decl)
4807      tree decl;
4808 {
4809   if (named_label_uses == NULL
4810       || named_label_uses->names_in_scope != current_binding_level->names
4811       || named_label_uses->label_decl != decl)
4812     {
4813       struct named_label_use_list *new_ent;
4814       new_ent = ((struct named_label_use_list *)
4815                  ggc_alloc (sizeof (struct named_label_use_list)));
4816       new_ent->label_decl = decl;
4817       new_ent->names_in_scope = current_binding_level->names;
4818       new_ent->binding_level = current_binding_level;
4819       new_ent->lineno_o_goto = lineno;
4820       new_ent->filename_o_goto = input_filename;
4821       new_ent->next = named_label_uses;
4822       named_label_uses = new_ent;
4823     }
4824 }
4825
4826 /* Look for a label named ID in the current function.  If one cannot
4827    be found, create one.  (We keep track of used, but undefined,
4828    labels, and complain about them at the end of a function.)  */
4829
4830 tree
4831 lookup_label (id)
4832      tree id;
4833 {
4834   tree decl;
4835   struct named_label_list *ent;
4836
4837   /* You can't use labels at global scope.  */
4838   if (current_function_decl == NULL_TREE)
4839     {
4840       error ("label `%s' referenced outside of any function",
4841              IDENTIFIER_POINTER (id));
4842       return NULL_TREE;
4843     }
4844
4845   /* See if we've already got this label.  */
4846   decl = IDENTIFIER_LABEL_VALUE (id);
4847   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4848     return decl;
4849
4850   /* Record this label on the list of labels used in this function.
4851      We do this before calling make_label_decl so that we get the
4852      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
4853   ent = ((struct named_label_list *)
4854          ggc_alloc_cleared (sizeof (struct named_label_list)));
4855   ent->old_value = IDENTIFIER_LABEL_VALUE (id);
4856   ent->next = named_labels;
4857   named_labels = ent;
4858
4859   /* We need a new label.  */
4860   decl = make_label_decl (id, /*local_p=*/0);
4861
4862   /* Now fill in the information we didn't have before.  */
4863   ent->label_decl = decl;
4864
4865   return decl;
4866 }
4867
4868 /* Declare a local label named ID.  */
4869
4870 tree
4871 declare_local_label (id)
4872      tree id;
4873 {
4874   tree decl;
4875
4876   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4877      this scope we can restore the old value of
4878      IDENTIFIER_TYPE_VALUE.  */
4879   current_binding_level->shadowed_labels
4880     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4881                  current_binding_level->shadowed_labels);
4882   /* Look for the label.  */
4883   decl = make_label_decl (id, /*local_p=*/1);
4884   /* Now fill in the information we didn't have before.  */
4885   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4886
4887   return decl;
4888 }
4889
4890 /* Returns nonzero if it is ill-formed to jump past the declaration of
4891    DECL.  Returns 2 if it's also a real problem.  */
4892
4893 static int
4894 decl_jump_unsafe (decl)
4895      tree decl;
4896 {
4897   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
4898     return 0;
4899
4900   if (DECL_INITIAL (decl) == NULL_TREE
4901       && pod_type_p (TREE_TYPE (decl)))
4902     return 0;
4903
4904   /* This is really only important if we're crossing an initialization.
4905      The POD stuff is just pedantry; why should it matter if the class
4906      contains a field of pointer to member type?  */
4907   if (DECL_INITIAL (decl)
4908       || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
4909     return 2;
4910   return 1;
4911 }
4912
4913 /* Check that a single previously seen jump to a newly defined label
4914    is OK.  DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
4915    the jump context; NAMES are the names in scope in LEVEL at the jump
4916    context; FILE and LINE are the source position of the jump or 0.  */
4917
4918 static void
4919 check_previous_goto_1 (decl, level, names, file, line)
4920      tree decl;
4921      struct binding_level *level;
4922      tree names;
4923      const char *file;
4924      int line;
4925 {
4926   int identified = 0;
4927   int saw_eh = 0;
4928   struct binding_level *b = current_binding_level;
4929   for (; b; b = b->level_chain)
4930     {
4931       tree new_decls = b->names;
4932       tree old_decls = (b == level ? names : NULL_TREE);
4933       for (; new_decls != old_decls;
4934            new_decls = TREE_CHAIN (new_decls))
4935         {
4936           int problem = decl_jump_unsafe (new_decls);
4937           if (! problem)
4938             continue;
4939
4940           if (! identified)
4941             {
4942               if (decl)
4943                 cp_pedwarn ("jump to label `%D'", decl);
4944               else
4945                 pedwarn ("jump to case label");
4946
4947               if (file)
4948                 pedwarn_with_file_and_line (file, line, "  from here");
4949               identified = 1;
4950             }
4951
4952           if (problem > 1 && DECL_ARTIFICIAL (new_decls))
4953             /* Can't skip init of __exception_info.  */
4954             cp_error_at ("  enters catch block", new_decls);
4955           else if (problem > 1)
4956             cp_error_at ("  crosses initialization of `%#D'",
4957                          new_decls);
4958           else
4959             cp_pedwarn_at ("  enters scope of non-POD `%#D'",
4960                            new_decls);
4961         }
4962
4963       if (b == level)
4964         break;
4965       if (b->eh_region && ! saw_eh)
4966         {
4967           if (! identified)
4968             {
4969               if (decl)
4970                 cp_pedwarn ("jump to label `%D'", decl);
4971               else
4972                 pedwarn ("jump to case label");
4973
4974               if (file)
4975                 pedwarn_with_file_and_line (file, line, "  from here");
4976               identified = 1;
4977             }
4978           error ("  enters try block");
4979           saw_eh = 1;
4980         }
4981     }
4982 }
4983
4984 static void
4985 check_previous_goto (use)
4986      struct named_label_use_list *use;
4987 {
4988   check_previous_goto_1 (use->label_decl, use->binding_level,
4989                          use->names_in_scope, use->filename_o_goto,
4990                          use->lineno_o_goto);
4991 }
4992
4993 static void
4994 check_switch_goto (level)
4995      struct binding_level *level;
4996 {
4997   check_previous_goto_1 (NULL_TREE, level, level->names, NULL, 0);
4998 }
4999
5000 /* Check that any previously seen jumps to a newly defined label DECL
5001    are OK.  Called by define_label.  */
5002
5003 static void
5004 check_previous_gotos (decl)
5005      tree decl;
5006 {
5007   struct named_label_use_list **usep;
5008
5009   if (! TREE_USED (decl))
5010     return;
5011
5012   for (usep = &named_label_uses; *usep; )
5013     {
5014       struct named_label_use_list *use = *usep;
5015       if (use->label_decl == decl)
5016         {
5017           check_previous_goto (use);
5018           *usep = use->next;
5019         }
5020       else
5021         usep = &(use->next);
5022     }
5023 }
5024
5025 /* Check that a new jump to a label DECL is OK.  Called by
5026    finish_goto_stmt.  */
5027
5028 void
5029 check_goto (decl)
5030      tree decl;
5031 {
5032   int identified = 0;
5033   tree bad;
5034   struct named_label_list *lab;
5035
5036   /* We can't know where a computed goto is jumping.  So we assume
5037      that it's OK.  */
5038   if (! DECL_P (decl))
5039     return;
5040
5041   /* If the label hasn't been defined yet, defer checking.  */
5042   if (! DECL_INITIAL (decl))
5043     {
5044       use_label (decl);
5045       return;
5046     }
5047
5048   for (lab = named_labels; lab; lab = lab->next)
5049     if (decl == lab->label_decl)
5050       break;
5051
5052   /* If the label is not on named_labels it's a gcc local label, so
5053      it must be in an outer scope, so jumping to it is always OK.  */
5054   if (lab == 0)
5055     return;
5056
5057   if ((lab->eh_region || lab->bad_decls) && !identified)
5058     {
5059       cp_pedwarn_at ("jump to label `%D'", decl);
5060       pedwarn ("  from here");
5061       identified = 1;
5062     }
5063
5064   for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad))
5065     {
5066       tree b = TREE_VALUE (bad);
5067       int u = decl_jump_unsafe (b);
5068
5069       if (u > 1 && DECL_ARTIFICIAL (b))
5070         /* Can't skip init of __exception_info.  */
5071         cp_error_at ("  enters catch block", b);
5072       else if (u > 1)
5073         cp_error_at ("  skips initialization of `%#D'", b);
5074       else
5075         cp_pedwarn_at ("  enters scope of non-POD `%#D'", b);
5076     }
5077
5078   if (lab->eh_region)
5079     error ("  enters try block");
5080 }
5081
5082 /* Define a label, specifying the location in the source file.
5083    Return the LABEL_DECL node for the label, if the definition is valid.
5084    Otherwise return 0.  */
5085
5086 tree
5087 define_label (filename, line, name)
5088      const char *filename;
5089      int line;
5090      tree name;
5091 {
5092   tree decl = lookup_label (name);
5093   struct named_label_list *ent;
5094
5095   for (ent = named_labels; ent; ent = ent->next)
5096     if (ent->label_decl == decl)
5097       break;
5098
5099   /* After labels, make any new cleanups go into their
5100      own new (temporary) binding contour.  */
5101   current_binding_level->more_cleanups_ok = 0;
5102
5103   if (name == get_identifier ("wchar_t"))
5104     cp_pedwarn ("label named wchar_t");
5105
5106   if (DECL_INITIAL (decl) != NULL_TREE)
5107     {
5108       cp_error ("duplicate label `%D'", decl);
5109       return 0;
5110     }
5111   else
5112     {
5113       /* Mark label as having been defined.  */
5114       DECL_INITIAL (decl) = error_mark_node;
5115       /* Say where in the source.  */
5116       DECL_SOURCE_FILE (decl) = filename;
5117       DECL_SOURCE_LINE (decl) = line;
5118       if (ent)
5119         {
5120           ent->names_in_scope = current_binding_level->names;
5121           ent->binding_level = current_binding_level;
5122         }
5123       check_previous_gotos (decl);
5124       current_function_return_value = NULL_TREE;
5125       return decl;
5126     }
5127 }
5128
5129 struct cp_switch
5130 {
5131   struct binding_level *level;
5132   struct cp_switch *next;
5133 };
5134
5135 static struct cp_switch *switch_stack;
5136
5137 void
5138 push_switch ()
5139 {
5140   struct cp_switch *p
5141     = (struct cp_switch *) xmalloc (sizeof (struct cp_switch));
5142   p->level = current_binding_level;
5143   p->next = switch_stack;
5144   switch_stack = p;
5145 }
5146
5147 void
5148 pop_switch ()
5149 {
5150   struct cp_switch *cs;
5151
5152   cs = switch_stack;
5153   switch_stack = switch_stack->next;
5154   free (cs);
5155 }
5156
5157 /* Note that we've seen a definition of a case label, and complain if this
5158    is a bad place for one.  */
5159
5160 void
5161 define_case_label ()
5162 {
5163   tree cleanup = last_cleanup_this_contour ();
5164
5165   if (! switch_stack)
5166     /* Don't crash; we'll complain in do_case.  */
5167     return;
5168
5169   if (cleanup)
5170     {
5171       static int explained = 0;
5172       cp_warning_at ("destructor needed for `%#D'", TREE_PURPOSE (cleanup));
5173       warning ("where case label appears here");
5174       if (!explained)
5175         {
5176           warning ("(enclose actions of previous case statements requiring");
5177           warning ("destructors in their own binding contours.)");
5178           explained = 1;
5179         }
5180     }
5181
5182   check_switch_goto (switch_stack->level);
5183
5184   /* After labels, make any new cleanups go into their
5185      own new (temporary) binding contour.  */
5186
5187   current_binding_level->more_cleanups_ok = 0;
5188   current_function_return_value = NULL_TREE;
5189 }
5190 \f
5191 /* Return the list of declarations of the current level.
5192    Note that this list is in reverse order unless/until
5193    you nreverse it; and when you do nreverse it, you must
5194    store the result back using `storedecls' or you will lose.  */
5195
5196 tree
5197 getdecls ()
5198 {
5199   return current_binding_level->names;
5200 }
5201
5202 /* Return the list of type-tags (for structs, etc) of the current level.  */
5203
5204 tree
5205 gettags ()
5206 {
5207   return current_binding_level->tags;
5208 }
5209
5210 /* Store the list of declarations of the current level.
5211    This is done for the parameter declarations of a function being defined,
5212    after they are modified in the light of any missing parameters.  */
5213
5214 static void
5215 storedecls (decls)
5216      tree decls;
5217 {
5218   current_binding_level->names = decls;
5219 }
5220
5221 /* Similarly, store the list of tags of the current level.  */
5222
5223 void
5224 storetags (tags)
5225      tree tags;
5226 {
5227   current_binding_level->tags = tags;
5228 }
5229 \f
5230 /* Given NAME, an IDENTIFIER_NODE,
5231    return the structure (or union or enum) definition for that name.
5232    Searches binding levels from BINDING_LEVEL up to the global level.
5233    If THISLEVEL_ONLY is nonzero, searches only the specified context
5234    (but skips any tag-transparent contexts to find one that is
5235    meaningful for tags).
5236    FORM says which kind of type the caller wants;
5237    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5238    If the wrong kind of type is found, and it's not a template, an error is
5239    reported.  */
5240
5241 static tree
5242 lookup_tag (form, name, binding_level, thislevel_only)
5243      enum tree_code form;
5244      tree name;
5245      struct binding_level *binding_level;
5246      int thislevel_only;
5247 {
5248   register struct binding_level *level;
5249   /* Non-zero if, we should look past a template parameter level, even
5250      if THISLEVEL_ONLY.  */
5251   int allow_template_parms_p = 1;
5252
5253   for (level = binding_level; level; level = level->level_chain)
5254     {
5255       register tree tail;
5256       if (ANON_AGGRNAME_P (name))
5257         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5258           {
5259             /* There's no need for error checking here, because
5260                anon names are unique throughout the compilation.  */
5261             if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
5262               return TREE_VALUE (tail);
5263           }
5264       else if (level->namespace_p)
5265         /* Do namespace lookup. */
5266         for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
5267           {
5268             tree old = binding_for_name (name, tail);
5269
5270             /* If we just skipped past a template parameter level,
5271                even though THISLEVEL_ONLY, and we find a template
5272                class declaration, then we use the _TYPE node for the
5273                template.  See the example below.  */
5274             if (thislevel_only && !allow_template_parms_p
5275                 && old && BINDING_VALUE (old)
5276                 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
5277               old = TREE_TYPE (BINDING_VALUE (old));
5278             else
5279               old = BINDING_TYPE (old);
5280
5281             /* If it has an original type, it is a typedef, and we
5282                should not return it.  */
5283             if (old && DECL_ORIGINAL_TYPE (TYPE_NAME (old)))
5284               old = NULL_TREE;
5285             if (old && TREE_CODE (old) != form
5286                 && !(form != ENUMERAL_TYPE && TREE_CODE (old) == TEMPLATE_DECL))
5287               {
5288                 cp_error ("`%#D' redeclared as %C", old, form);
5289                 return NULL_TREE;
5290               }
5291             if (old)
5292               return old;
5293             if (thislevel_only || tail == global_namespace)
5294               return NULL_TREE;
5295           }
5296       else
5297         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5298           {
5299             if (TREE_PURPOSE (tail) == name)
5300               {
5301                 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5302                 /* Should tighten this up; it'll probably permit
5303                    UNION_TYPE and a struct template, for example.  */
5304                 if (code != form
5305                     && !(form != ENUMERAL_TYPE && code == TEMPLATE_DECL))
5306                   {
5307                     /* Definition isn't the kind we were looking for.  */
5308                     cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
5309                               form);
5310                     return NULL_TREE;
5311                   }
5312                 return TREE_VALUE (tail);
5313               }
5314           }
5315       if (thislevel_only && ! level->tag_transparent)
5316         {
5317           if (level->template_parms_p && allow_template_parms_p)
5318             {
5319               /* We must deal with cases like this:
5320
5321                    template <class T> struct S;
5322                    template <class T> struct S {};
5323
5324                  When looking up `S', for the second declaration, we
5325                  would like to find the first declaration.  But, we
5326                  are in the pseudo-global level created for the
5327                  template parameters, rather than the (surrounding)
5328                  namespace level.  Thus, we keep going one more level,
5329                  even though THISLEVEL_ONLY is non-zero.  */
5330               allow_template_parms_p = 0;
5331               continue;
5332             }
5333           else
5334             return NULL_TREE;
5335         }
5336     }
5337   return NULL_TREE;
5338 }
5339
5340 #if 0
5341 void
5342 set_current_level_tags_transparency (tags_transparent)
5343      int tags_transparent;
5344 {
5345   current_binding_level->tag_transparent = tags_transparent;
5346 }
5347 #endif
5348
5349 /* Given a type, find the tag that was defined for it and return the tag name.
5350    Otherwise return 0.  However, the value can never be 0
5351    in the cases in which this is used.
5352
5353    C++: If NAME is non-zero, this is the new name to install.  This is
5354    done when replacing anonymous tags with real tag names.  */
5355
5356 static tree
5357 lookup_tag_reverse (type, name)
5358      tree type;
5359      tree name;
5360 {
5361   register struct binding_level *level;
5362
5363   for (level = current_binding_level; level; level = level->level_chain)
5364     {
5365       register tree tail;
5366       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5367         {
5368           if (TREE_VALUE (tail) == type)
5369             {
5370               if (name)
5371                 TREE_PURPOSE (tail) = name;
5372               return TREE_PURPOSE (tail);
5373             }
5374         }
5375     }
5376   return NULL_TREE;
5377 }
5378 \f
5379 /* Look up NAME in the NAMESPACE.  */
5380
5381 tree
5382 lookup_namespace_name (namespace, name)
5383      tree namespace, name;
5384 {
5385   tree val;
5386   tree template_id = NULL_TREE;
5387
5388   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5389
5390   if (TREE_CODE (name) == NAMESPACE_DECL)
5391     /* This happens for A::B<int> when B is a namespace. */
5392     return name;
5393   else if (TREE_CODE (name) == TEMPLATE_DECL)
5394     {
5395       /* This happens for A::B where B is a template, and there are no
5396          template arguments.  */
5397       cp_error ("invalid use of `%D'", name);
5398       return error_mark_node;
5399     }
5400
5401   namespace = ORIGINAL_NAMESPACE (namespace);
5402
5403   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5404     {
5405       template_id = name;
5406       name = TREE_OPERAND (name, 0);
5407       if (TREE_CODE (name) == OVERLOAD)
5408         name = DECL_NAME (OVL_CURRENT (name));
5409       else if (DECL_P (name))
5410         name = DECL_NAME (name);
5411     }
5412
5413   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5414
5415   val = make_node (CPLUS_BINDING);
5416   if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5417     return error_mark_node;
5418
5419   if (BINDING_VALUE (val))
5420     {
5421       val = BINDING_VALUE (val);
5422
5423       if (template_id)
5424         {
5425           if (DECL_CLASS_TEMPLATE_P (val))
5426             val = lookup_template_class (val,
5427                                          TREE_OPERAND (template_id, 1),
5428                                          /*in_decl=*/NULL_TREE,
5429                                          /*context=*/NULL_TREE,
5430                                          /*entering_scope=*/0);
5431           else if (DECL_FUNCTION_TEMPLATE_P (val)
5432                    || TREE_CODE (val) == OVERLOAD)
5433             val = lookup_template_function (val,
5434                                             TREE_OPERAND (template_id, 1));
5435           else
5436             {
5437               cp_error ("`%D::%D' is not a template",
5438                         namespace, name);
5439               return error_mark_node;
5440             }
5441         }
5442
5443       /* If we have a single function from a using decl, pull it out.  */
5444       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5445         val = OVL_FUNCTION (val);
5446       return val;
5447     }
5448
5449   cp_error ("`%D' undeclared in namespace `%D'", name, namespace);
5450   return error_mark_node;
5451 }
5452
5453 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
5454
5455 static unsigned long
5456 typename_hash (k)
5457      hash_table_key k;
5458 {
5459   unsigned long hash;
5460   tree t;
5461
5462   t = (tree) k;
5463   hash = (((unsigned long) TYPE_CONTEXT (t))
5464           ^ ((unsigned long) DECL_NAME (TYPE_NAME (t))));
5465
5466   return hash;
5467 }
5468
5469 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
5470
5471 static boolean
5472 typename_compare (k1, k2)
5473      hash_table_key k1;
5474      hash_table_key k2;
5475 {
5476   tree t1;
5477   tree t2;
5478   tree d1;
5479   tree d2;
5480
5481   t1 = (tree) k1;
5482   t2 = (tree) k2;
5483   d1 = TYPE_NAME (t1);
5484   d2 = TYPE_NAME (t2);
5485
5486   return (DECL_NAME (d1) == DECL_NAME (d2)
5487           && same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))
5488           && ((TREE_TYPE (t1) != NULL_TREE)
5489               == (TREE_TYPE (t2) != NULL_TREE))
5490           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5491           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5492 }
5493
5494 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
5495    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
5496    is non-NULL, this type is being created by the implicit typename
5497    extension, and BASE_TYPE is a type named `t' in some base class of
5498    `T' which depends on template parameters.
5499
5500    Returns the new TYPENAME_TYPE.  */
5501
5502 tree
5503 build_typename_type (context, name, fullname, base_type)
5504      tree context;
5505      tree name;
5506      tree fullname;
5507      tree base_type;
5508 {
5509   tree t;
5510   tree d;
5511   struct hash_entry* e;
5512
5513   static struct hash_table ht;
5514
5515   if (!ht.table)
5516     {
5517       static struct hash_table *h = &ht;
5518       if (!hash_table_init (&ht, &hash_newfunc, &typename_hash,
5519                             &typename_compare))
5520         fatal ("virtual memory exhausted");
5521       ggc_add_tree_hash_table_root (&h, 1);
5522     }
5523
5524   /* Build the TYPENAME_TYPE.  */
5525   t = make_aggr_type (TYPENAME_TYPE);
5526   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5527   TYPENAME_TYPE_FULLNAME (t) = fullname;
5528   TREE_TYPE (t) = base_type;
5529
5530   /* Build the corresponding TYPE_DECL.  */
5531   d = build_decl (TYPE_DECL, name, t);
5532   TYPE_NAME (TREE_TYPE (d)) = d;
5533   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5534   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5535   DECL_ARTIFICIAL (d) = 1;
5536
5537   /* See if we already have this type.  */
5538   e = hash_lookup (&ht, t, /*create=*/false, /*copy=*/0);
5539   if (e)
5540     t = (tree) e->key;
5541   else
5542     /* Insert the type into the table.  */
5543     hash_lookup (&ht, t, /*create=*/true, /*copy=*/0);
5544
5545   return t;
5546 }
5547
5548 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
5549    unless an error occurs, in which case error_mark_node is returned.
5550    If COMPLAIN zero, don't complain about any errors that occur.  */
5551
5552 tree
5553 make_typename_type (context, name, complain)
5554      tree context, name;
5555      int complain;
5556 {
5557   tree fullname;
5558
5559   if (TYPE_P (name))
5560     {
5561       if (!(TYPE_LANG_SPECIFIC (name)
5562             && (CLASSTYPE_IS_TEMPLATE (name)
5563                 || CLASSTYPE_USE_TEMPLATE (name))))
5564         name = TYPE_IDENTIFIER (name);
5565       else
5566         /* Create a TEMPLATE_ID_EXPR for the type.  */
5567         name = build_nt (TEMPLATE_ID_EXPR,
5568                          CLASSTYPE_TI_TEMPLATE (name),
5569                          CLASSTYPE_TI_ARGS (name));
5570     }
5571   else if (TREE_CODE (name) == TYPE_DECL)
5572     name = DECL_NAME (name);
5573
5574   fullname = name;
5575
5576   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5577     {
5578       name = TREE_OPERAND (name, 0);
5579       if (TREE_CODE (name) == TEMPLATE_DECL)
5580         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5581     }
5582   if (TREE_CODE (name) != IDENTIFIER_NODE)
5583     my_friendly_abort (2000);
5584
5585   if (TREE_CODE (context) == NAMESPACE_DECL)
5586     {
5587       /* We can get here from typename_sub0 in the explicit_template_type
5588          expansion.  Just fail.  */
5589       if (complain)
5590         cp_error ("no class template named `%#T' in `%#T'",
5591                   name, context);
5592       return error_mark_node;
5593     }
5594
5595   if (! uses_template_parms (context)
5596       || currently_open_class (context))
5597     {
5598       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5599         {
5600           tree tmpl = NULL_TREE;
5601           if (IS_AGGR_TYPE (context))
5602             tmpl = lookup_field (context, name, 0, 0);
5603           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5604             {
5605               if (complain)
5606                 cp_error ("no class template named `%#T' in `%#T'",
5607                           name, context);
5608               return error_mark_node;
5609             }
5610
5611           return lookup_template_class (tmpl,
5612                                         TREE_OPERAND (fullname, 1),
5613                                         NULL_TREE, context,
5614                                         /*entering_scope=*/0);
5615         }
5616       else
5617         {
5618           tree t;
5619
5620           if (!IS_AGGR_TYPE (context))
5621             {
5622               if (complain)
5623                 cp_error ("no type named `%#T' in `%#T'", name, context);
5624               return error_mark_node;
5625             }
5626
5627           t = lookup_field (context, name, 0, 1);
5628           if (t)
5629             return TREE_TYPE (t);
5630         }
5631     }
5632
5633   /* If the CONTEXT is not a template type, then either the field is
5634      there now or its never going to be.  */
5635   if (!uses_template_parms (context))
5636     {
5637       if (complain)
5638         cp_error ("no type named `%#T' in `%#T'", name, context);
5639       return error_mark_node;
5640     }
5641
5642
5643   return build_typename_type (context, name, fullname,  NULL_TREE);
5644 }
5645
5646 /* Select the right _DECL from multiple choices. */
5647
5648 static tree
5649 select_decl (binding, flags)
5650      tree binding;
5651      int flags;
5652 {
5653   tree val;
5654   val = BINDING_VALUE (binding);
5655   if (LOOKUP_NAMESPACES_ONLY (flags))
5656     {
5657       /* We are not interested in types. */
5658       if (val && TREE_CODE (val) == NAMESPACE_DECL)
5659         return val;
5660       return NULL_TREE;
5661     }
5662
5663   /* If we could have a type and
5664      we have nothing or we need a type and have none.  */
5665   if (BINDING_TYPE (binding)
5666       && (!val || ((flags & LOOKUP_PREFER_TYPES)
5667                    && TREE_CODE (val) != TYPE_DECL)))
5668     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5669   /* Don't return non-types if we really prefer types. */
5670   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
5671            && (TREE_CODE (val) != TEMPLATE_DECL
5672                || !DECL_CLASS_TEMPLATE_P (val)))
5673     val = NULL_TREE;
5674
5675   return val;
5676 }
5677
5678 /* Unscoped lookup of a global: iterate over current namespaces,
5679    considering using-directives.  If SPACESP is non-NULL, store a list
5680    of the namespaces we've considered in it.  */
5681
5682 tree
5683 unqualified_namespace_lookup (name, flags, spacesp)
5684      tree name;
5685      int flags;
5686      tree *spacesp;
5687 {
5688   tree b = make_node (CPLUS_BINDING);
5689   tree initial = current_decl_namespace();
5690   tree scope = initial;
5691   tree siter;
5692   struct binding_level *level;
5693   tree val = NULL_TREE;
5694
5695   if (spacesp)
5696     *spacesp = NULL_TREE;
5697
5698   for (; !val; scope = CP_DECL_CONTEXT (scope))
5699     {
5700       if (spacesp)
5701         *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5702       val = binding_for_name (name, scope);
5703
5704       /* Initialize binding for this context. */
5705       BINDING_VALUE (b) = BINDING_VALUE (val);
5706       BINDING_TYPE (b) = BINDING_TYPE (val);
5707
5708       /* Add all _DECLs seen through local using-directives. */
5709       for (level = current_binding_level;
5710            !level->namespace_p;
5711            level = level->level_chain)
5712         if (!lookup_using_namespace (name, b, level->using_directives,
5713                                      scope, flags, spacesp))
5714           /* Give up because of error. */
5715           return error_mark_node;
5716
5717       /* Add all _DECLs seen through global using-directives. */
5718       /* XXX local and global using lists should work equally. */
5719       siter = initial;
5720       while (1)
5721         {
5722           if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5723                                        scope, flags, spacesp))
5724             /* Give up because of error. */
5725             return error_mark_node;
5726           if (siter == scope) break;
5727           siter = CP_DECL_CONTEXT (siter);
5728         }
5729
5730       val = select_decl (b, flags);
5731       if (scope == global_namespace)
5732         break;
5733     }
5734   return val;
5735 }
5736
5737 /* Combine prefer_type and namespaces_only into flags.  */
5738
5739 static int
5740 lookup_flags (prefer_type, namespaces_only)
5741   int prefer_type, namespaces_only;
5742 {
5743   if (namespaces_only)
5744     return LOOKUP_PREFER_NAMESPACES;
5745   if (prefer_type > 1)
5746     return LOOKUP_PREFER_TYPES;
5747   if (prefer_type > 0)
5748     return LOOKUP_PREFER_BOTH;
5749   return 0;
5750 }
5751
5752 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5753    ignore it or not.  Subroutine of lookup_name_real.  */
5754
5755 static tree
5756 qualify_lookup (val, flags)
5757      tree val;
5758      int flags;
5759 {
5760   if (val == NULL_TREE)
5761     return val;
5762   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5763     return val;
5764   if ((flags & LOOKUP_PREFER_TYPES)
5765       && (TREE_CODE (val) == TYPE_DECL
5766           || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5767               && DECL_CLASS_TEMPLATE_P (val))))
5768     return val;
5769   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5770     return NULL_TREE;
5771   return val;
5772 }
5773
5774 /* Any other BINDING overrides an implicit TYPENAME.  Warn about
5775    that.  */
5776
5777 static void
5778 warn_about_implicit_typename_lookup (typename, binding)
5779      tree typename;
5780      tree binding;
5781 {
5782   tree subtype = TREE_TYPE (TREE_TYPE (typename));
5783   tree name = DECL_NAME (typename);
5784
5785   if (! (TREE_CODE (binding) == TEMPLATE_DECL
5786          && CLASSTYPE_TEMPLATE_INFO (subtype)
5787          && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
5788       && ! (TREE_CODE (binding) == TYPE_DECL
5789             && same_type_p (TREE_TYPE (binding), subtype)))
5790     {
5791       cp_warning ("lookup of `%D' finds `%#D'",
5792                   name, binding);
5793       cp_warning ("  instead of `%D' from dependent base class",
5794                   typename);
5795       cp_warning ("  (use `typename %T::%D' if that's what you meant)",
5796                   constructor_name (current_class_type), name);
5797     }
5798 }
5799
5800 /* Look up NAME in the current binding level and its superiors in the
5801    namespace of variables, functions and typedefs.  Return a ..._DECL
5802    node of some kind representing its definition if there is only one
5803    such declaration, or return a TREE_LIST with all the overloaded
5804    definitions if there are many, or return 0 if it is undefined.
5805
5806    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5807    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5808    If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5809    Otherwise we prefer non-TYPE_DECLs.
5810
5811    If NONCLASS is non-zero, we don't look for the NAME in class scope,
5812    using IDENTIFIER_CLASS_VALUE.  */
5813
5814 static tree
5815 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
5816      tree name;
5817      int prefer_type, nonclass, namespaces_only;
5818 {
5819   tree t;
5820   tree val = NULL_TREE;
5821   int yylex = 0;
5822   tree from_obj = NULL_TREE;
5823   int flags;
5824   int val_is_implicit_typename = 0;
5825
5826   /* Hack: copy flag set by parser, if set. */
5827   if (only_namespace_names)
5828     namespaces_only = 1;
5829
5830   if (prefer_type == -2)
5831     {
5832       extern int looking_for_typename;
5833       tree type = NULL_TREE;
5834
5835       yylex = 1;
5836       prefer_type = looking_for_typename;
5837
5838       flags = lookup_flags (prefer_type, namespaces_only);
5839       /* If the next thing is '<', class templates are types. */
5840       if (looking_for_template)
5841         flags |= LOOKUP_TEMPLATES_EXPECTED;
5842
5843       /* std:: becomes :: for now.  */
5844       if (got_scope == std_node)
5845         got_scope = void_type_node;
5846
5847       if (got_scope)
5848         type = got_scope;
5849       else if (got_object != error_mark_node)
5850         type = got_object;
5851
5852       if (type)
5853         {
5854           if (type == error_mark_node)
5855             return error_mark_node;
5856           if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
5857             type = TREE_TYPE (type);
5858
5859           if (TYPE_P (type))
5860             type = complete_type (type);
5861
5862           if (TREE_CODE (type) == VOID_TYPE)
5863             type = global_namespace;
5864           if (TREE_CODE (type) == NAMESPACE_DECL)
5865             {
5866               val = make_node (CPLUS_BINDING);
5867               flags |= LOOKUP_COMPLAIN;
5868               if (!qualified_lookup_using_namespace (name, type, val, flags))
5869                 return NULL_TREE;
5870               val = select_decl (val, flags);
5871             }
5872           else if (! IS_AGGR_TYPE (type)
5873                    || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5874                    || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM
5875                    || TREE_CODE (type) == TYPENAME_TYPE)
5876             /* Someone else will give an error about this if needed.  */
5877             val = NULL_TREE;
5878           else if (type == current_class_type)
5879             val = IDENTIFIER_CLASS_VALUE (name);
5880           else
5881             {
5882               val = lookup_member (type, name, 0, prefer_type);
5883               type_access_control (type, val);
5884             }
5885         }
5886       else
5887         val = NULL_TREE;
5888
5889       if (got_scope)
5890         goto done;
5891       else if (got_object && val)
5892         from_obj = val;
5893     }
5894   else
5895     {
5896       flags = lookup_flags (prefer_type, namespaces_only);
5897       /* If we're not parsing, we need to complain. */
5898       flags |= LOOKUP_COMPLAIN;
5899     }
5900
5901   /* First, look in non-namespace scopes.  */
5902
5903   if (current_class_type == NULL_TREE)
5904     nonclass = 1;
5905
5906   for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
5907     {
5908       tree binding;
5909
5910       if (!LOCAL_BINDING_P (t) && nonclass)
5911         /* We're not looking for class-scoped bindings, so keep going.  */
5912         continue;
5913
5914       /* If this is the kind of thing we're looking for, we're done.  */
5915       if (qualify_lookup (BINDING_VALUE (t), flags))
5916         binding = BINDING_VALUE (t);
5917       else if ((flags & LOOKUP_PREFER_TYPES)
5918                && qualify_lookup (BINDING_TYPE (t), flags))
5919         binding = BINDING_TYPE (t);
5920       else
5921         binding = NULL_TREE;
5922
5923       /* Handle access control on types from enclosing or base classes.  */
5924       if (binding && ! yylex
5925           && BINDING_LEVEL (t) && BINDING_LEVEL (t)->parm_flag == 2)
5926         type_access_control (BINDING_LEVEL (t)->this_class, binding);
5927
5928       if (binding
5929           && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
5930         {
5931           if (val_is_implicit_typename && !yylex)
5932             warn_about_implicit_typename_lookup (val, binding);
5933           val = binding;
5934           val_is_implicit_typename
5935             = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
5936           if (!val_is_implicit_typename)
5937             break;
5938         }
5939     }
5940
5941   /* Now lookup in namespace scopes.  */
5942   if (!val || val_is_implicit_typename)
5943     {
5944       t = unqualified_namespace_lookup (name, flags, 0);
5945       if (t)
5946         {
5947           if (val_is_implicit_typename && !yylex)
5948             warn_about_implicit_typename_lookup (val, t);
5949           val = t;
5950         }
5951     }
5952
5953  done:
5954   if (val)
5955     {
5956       /* This should only warn about types used in qualified-ids.  */
5957       if (from_obj && from_obj != val)
5958         {
5959           if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
5960               && TREE_CODE (val) == TYPE_DECL
5961               && TREE_TYPE (from_obj) != TREE_TYPE (val))
5962             {
5963               cp_pedwarn ("lookup of `%D' in the scope of `%#T' (`%#T')",
5964                           name, got_object, TREE_TYPE (from_obj));
5965               cp_pedwarn ("  does not match lookup in the current scope (`%#T')",
5966                           TREE_TYPE (val));
5967             }
5968
5969           /* We don't change val to from_obj if got_object depends on
5970              template parms because that breaks implicit typename for
5971              destructor calls.  */
5972           if (! uses_template_parms (got_object))
5973             val = from_obj;
5974         }
5975
5976       /* If we have a single function from a using decl, pull it out.  */
5977       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5978         val = OVL_FUNCTION (val);
5979     }
5980   else if (from_obj)
5981     val = from_obj;
5982
5983   return val;
5984 }
5985
5986 tree
5987 lookup_name_nonclass (name)
5988      tree name;
5989 {
5990   return lookup_name_real (name, 0, 1, 0);
5991 }
5992
5993 tree
5994 lookup_function_nonclass (name, args)
5995      tree name;
5996      tree args;
5997 {
5998   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
5999 }
6000
6001 tree
6002 lookup_name_namespace_only (name)
6003      tree name;
6004 {
6005   /* type-or-namespace, nonclass, namespace_only */
6006   return lookup_name_real (name, 1, 1, 1);
6007 }
6008
6009 tree
6010 lookup_name (name, prefer_type)
6011      tree name;
6012      int prefer_type;
6013 {
6014   return lookup_name_real (name, prefer_type, 0, 0);
6015 }
6016
6017 /* Similar to `lookup_name' but look only in the innermost non-class
6018    binding level.  */
6019
6020 tree
6021 lookup_name_current_level (name)
6022      tree name;
6023 {
6024   struct binding_level *b;
6025   tree t = NULL_TREE;
6026
6027   b = current_binding_level;
6028   while (b->parm_flag == 2)
6029     b = b->level_chain;
6030
6031   if (b->namespace_p)
6032     {
6033       t = IDENTIFIER_NAMESPACE_VALUE (name);
6034
6035       /* extern "C" function() */
6036       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
6037         t = TREE_VALUE (t);
6038     }
6039   else if (IDENTIFIER_BINDING (name)
6040            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
6041     {
6042       while (1)
6043         {
6044           if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
6045             return IDENTIFIER_VALUE (name);
6046
6047           if (b->keep == 2)
6048             b = b->level_chain;
6049           else
6050             break;
6051         }
6052     }
6053
6054   return t;
6055 }
6056
6057 /* Like lookup_name_current_level, but for types.  */
6058
6059 tree
6060 lookup_type_current_level (name)
6061      tree name;
6062 {
6063   register tree t = NULL_TREE;
6064
6065   my_friendly_assert (! current_binding_level->namespace_p, 980716);
6066
6067   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
6068       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
6069     {
6070       struct binding_level *b = current_binding_level;
6071       while (1)
6072         {
6073           if (purpose_member (name, b->type_shadowed))
6074             return REAL_IDENTIFIER_TYPE_VALUE (name);
6075           if (b->keep == 2)
6076             b = b->level_chain;
6077           else
6078             break;
6079         }
6080     }
6081
6082   return t;
6083 }
6084
6085 void
6086 begin_only_namespace_names ()
6087 {
6088   only_namespace_names = 1;
6089 }
6090
6091 void
6092 end_only_namespace_names ()
6093 {
6094   only_namespace_names = 0;
6095 }
6096 \f
6097 /* Push the declarations of builtin types into the namespace.
6098    RID_INDEX, if < CP_RID_MAX is the index of the builtin type
6099    in the array RID_POINTERS.  NAME is the name used when looking
6100    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
6101
6102 static void
6103 record_builtin_type (rid_index, name, type)
6104      enum rid rid_index;
6105      const char *name;
6106      tree type;
6107 {
6108   tree rname = NULL_TREE, tname = NULL_TREE;
6109   tree tdecl = NULL_TREE;
6110
6111   if ((int) rid_index < (int) CP_RID_MAX)
6112     rname = ridpointers[(int) rid_index];
6113   if (name)
6114     tname = get_identifier (name);
6115
6116   TYPE_BUILT_IN (type) = 1;
6117
6118   if (tname)
6119     {
6120       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
6121       set_identifier_type_value (tname, NULL_TREE);
6122       if ((int) rid_index < (int) CP_RID_MAX)
6123         /* Built-in types live in the global namespace. */
6124         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
6125     }
6126   if (rname != NULL_TREE)
6127     {
6128       if (tname != NULL_TREE)
6129         {
6130           set_identifier_type_value (rname, NULL_TREE);
6131           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
6132         }
6133       else
6134         {
6135           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
6136           set_identifier_type_value (rname, NULL_TREE);
6137         }
6138     }
6139 }
6140
6141 /* Record one of the standard Java types.
6142  * Declare it as having the given NAME.
6143  * If SIZE > 0, it is the size of one of the integral types;
6144  * otherwise it is the negative of the size of one of the other types.  */
6145
6146 static tree
6147 record_builtin_java_type (name, size)
6148      const char *name;
6149      int size;
6150 {
6151   tree type, decl;
6152   if (size > 0)
6153     type = make_signed_type (size);
6154   else if (size > -32)
6155     { /* "__java_char" or ""__java_boolean". */
6156       type = make_unsigned_type (-size);
6157       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6158     }
6159   else
6160     { /* "__java_float" or ""__java_double". */
6161       type = make_node (REAL_TYPE);
6162       TYPE_PRECISION (type) = - size;
6163       layout_type (type);
6164     }
6165   record_builtin_type (CP_RID_MAX, name, type);
6166   decl = TYPE_NAME (type);
6167
6168   /* Suppress generate debug symbol entries for these types,
6169      since for normal C++ they are just clutter.
6170      However, push_lang_context undoes this if extern "Java" is seen. */
6171   DECL_IGNORED_P (decl) = 1;
6172
6173   TYPE_FOR_JAVA (type) = 1;
6174   return type;
6175 }
6176
6177 /* Push a type into the namespace so that the back-ends ignore it. */
6178
6179 static void
6180 record_unknown_type (type, name)
6181      tree type;
6182      const char *name;
6183 {
6184   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
6185   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
6186   DECL_IGNORED_P (decl) = 1;
6187   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6188   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
6189   TYPE_ALIGN (type) = 1;
6190   TYPE_USER_ALIGN (type) = 0;
6191   TYPE_MODE (type) = TYPE_MODE (void_type_node);
6192 }
6193
6194 /* An string for which we should create an IDENTIFIER_NODE at
6195    startup.  */
6196
6197 typedef struct predefined_identifier
6198 {
6199   /* The name of the identifier.  */
6200   const char *name;
6201   /* The place where the IDENTIFIER_NODE should be stored.  */
6202   tree *node;
6203   /* Non-zero if this is the name of a constructor or destructor.  */
6204   int ctor_or_dtor_p;
6205 } predefined_identifier;
6206
6207 /* Create all the predefined identifiers.  */
6208
6209 static void
6210 initialize_predefined_identifiers ()
6211 {
6212   struct predefined_identifier *pid;
6213
6214   /* A table of identifiers to create at startup.  */
6215   static predefined_identifier predefined_identifiers[] = {
6216     { "C++", &lang_name_cplusplus, 0 },
6217     { "C", &lang_name_c, 0 },
6218     { "Java", &lang_name_java, 0 },
6219     { CTOR_NAME, &ctor_identifier, 1 },
6220     { "__base_ctor", &base_ctor_identifier, 1 },
6221     { "__comp_ctor", &complete_ctor_identifier, 1 },
6222     { DTOR_NAME, &dtor_identifier, 1 },
6223     { "__comp_dtor", &complete_dtor_identifier, 1 },
6224     { "__base_dtor", &base_dtor_identifier, 1 },
6225     { "__deleting_dtor", &deleting_dtor_identifier, 1 },
6226     { VTABLE_DELTA2_NAME, &delta2_identifier, 0 },
6227     { VTABLE_DELTA_NAME, &delta_identifier, 0 },
6228     { IN_CHARGE_NAME, &in_charge_identifier, 0 },
6229     { VTABLE_INDEX_NAME, &index_identifier, 0 },
6230     { "nelts", &nelts_identifier, 0 },
6231     { THIS_NAME, &this_identifier, 0 },
6232     { VTABLE_PFN_NAME, &pfn_identifier, 0 },
6233     { "__pfn_or_delta2", &pfn_or_delta2_identifier, 0 },
6234     { "_vptr", &vptr_identifier, 0 },
6235     { "__cp_push_exception", &cp_push_exception_identifier, 0 },
6236     { "__vtt_parm", &vtt_parm_identifier, 0 },
6237     { "std", &std_identifier, 0 },
6238     { NULL, NULL, 0 }
6239   };
6240
6241   for (pid = predefined_identifiers; pid->name; ++pid)
6242     {
6243       *pid->node = get_identifier (pid->name);
6244       if (pid->ctor_or_dtor_p)
6245         IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
6246     }
6247 }
6248
6249 /* Create the predefined scalar types of C,
6250    and some nodes representing standard constants (0, 1, (void *)0).
6251    Initialize the global binding level.
6252    Make definitions for built-in primitive functions.  */
6253
6254 void
6255 init_decl_processing ()
6256 {
6257   tree fields[20];
6258   int wchar_type_size;
6259   tree array_domain_type;
6260
6261   /* Check to see that the user did not specify an invalid combination
6262      of command-line options.  */
6263   if (flag_new_abi && !flag_vtable_thunks)
6264     fatal ("the new ABI requires vtable thunks");
6265
6266   /* Create all the identifiers we need.  */
6267   initialize_predefined_identifiers ();
6268
6269   /* Let the back-end now how to save and restore language-specific
6270      per-function globals.  */
6271   init_lang_status = &push_cp_function_context;
6272   free_lang_status = &pop_cp_function_context;
6273   mark_lang_status = &mark_cp_function_context;
6274
6275   cp_parse_init ();
6276   init_decl2 ();
6277   init_pt ();
6278
6279   /* Create the global variables.  */
6280   push_to_top_level ();
6281
6282   /* Enter the global namespace. */
6283   my_friendly_assert (global_namespace == NULL_TREE, 375);
6284   push_namespace (get_identifier ("::"));
6285   global_namespace = current_namespace;
6286   current_lang_name = NULL_TREE;
6287
6288   /* Adjust various flags based on command-line settings.  */
6289   if (flag_strict_prototype == 2)
6290     flag_strict_prototype = pedantic;
6291   if (! flag_permissive && ! pedantic)
6292     flag_pedantic_errors = 1;
6293   if (!flag_no_inline)
6294     flag_inline_trees = 1;
6295
6296   strict_prototypes_lang_c = flag_strict_prototype;
6297
6298   /* Initially, C.  */
6299   current_lang_name = lang_name_c;
6300
6301   current_function_decl = NULL_TREE;
6302   current_binding_level = NULL_BINDING_LEVEL;
6303   free_binding_level = NULL_BINDING_LEVEL;
6304
6305   build_common_tree_nodes (flag_signed_char);
6306
6307   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6308   TREE_TYPE (error_mark_list) = error_mark_node;
6309
6310   /* Make the binding_level structure for global names.  */
6311   pushlevel (0);
6312   global_binding_level = current_binding_level;
6313   /* The global level is the namespace level of ::.  */
6314   NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6315   declare_namespace_level ();
6316
6317   /* Define `int' and `char' first so that dbx will output them first.  */
6318   record_builtin_type (RID_INT, NULL_PTR, integer_type_node);
6319   record_builtin_type (RID_CHAR, "char", char_type_node);
6320
6321   /* `signed' is the same as `int' */
6322   record_builtin_type (RID_SIGNED, NULL_PTR, integer_type_node);
6323   record_builtin_type (RID_LONG, "long int", long_integer_type_node);
6324   record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
6325   record_builtin_type (CP_RID_MAX, "long unsigned int",
6326                        long_unsigned_type_node);
6327   record_builtin_type (CP_RID_MAX, "unsigned long", long_unsigned_type_node);
6328   record_builtin_type (CP_RID_MAX, "long long int",
6329                        long_long_integer_type_node);
6330   record_builtin_type (CP_RID_MAX, "long long unsigned int",
6331                        long_long_unsigned_type_node);
6332   record_builtin_type (CP_RID_MAX, "long long unsigned",
6333                        long_long_unsigned_type_node);
6334   record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
6335   record_builtin_type (CP_RID_MAX, "short unsigned int",
6336                        short_unsigned_type_node);
6337   record_builtin_type (CP_RID_MAX, "unsigned short",
6338                        short_unsigned_type_node);
6339
6340   ptrdiff_type_node
6341     = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE)));
6342
6343   /* Define both `signed char' and `unsigned char'.  */
6344   record_builtin_type (CP_RID_MAX, "signed char", signed_char_type_node);
6345   record_builtin_type (CP_RID_MAX, "unsigned char", unsigned_char_type_node);
6346
6347   /* `unsigned long' is the standard type for sizeof.
6348      Note that stddef.h uses `unsigned long',
6349      and this must agree, even if long and int are the same size.  */
6350   set_sizetype
6351     (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE))));
6352
6353   /* Create the widest literal types. */
6354   widest_integer_literal_type_node = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
6355   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6356                         widest_integer_literal_type_node));
6357
6358   widest_unsigned_literal_type_node = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
6359   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6360                         widest_unsigned_literal_type_node));
6361
6362   /* These are types that type_for_size and type_for_mode use.  */
6363   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
6364   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
6365   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
6366   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
6367 #if HOST_BITS_PER_WIDE_INT >= 64
6368   pushdecl (build_decl (TYPE_DECL, get_identifier ("__int128_t"), intTI_type_node));
6369 #endif
6370   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
6371   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
6372   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
6373   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
6374 #if HOST_BITS_PER_WIDE_INT >= 64
6375   pushdecl (build_decl (TYPE_DECL, get_identifier ("__uint128_t"), unsigned_intTI_type_node));
6376 #endif
6377
6378   build_common_tree_nodes_2 (flag_short_double);
6379
6380   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6381   java_short_type_node = record_builtin_java_type ("__java_short", 16);
6382   java_int_type_node = record_builtin_java_type ("__java_int", 32);
6383   java_long_type_node = record_builtin_java_type ("__java_long", 64);
6384   java_float_type_node = record_builtin_java_type ("__java_float", -32);
6385   java_double_type_node = record_builtin_java_type ("__java_double", -64);
6386   java_char_type_node = record_builtin_java_type ("__java_char", -16);
6387   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6388
6389   integer_two_node = build_int_2 (2, 0);
6390   TREE_TYPE (integer_two_node) = integer_type_node;
6391   integer_three_node = build_int_2 (3, 0);
6392   TREE_TYPE (integer_three_node) = integer_type_node;
6393
6394   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6395   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6396   TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6397   TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6398   TYPE_PRECISION (boolean_type_node) = 1;
6399   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6400   boolean_false_node = build_int_2 (0, 0);
6401   TREE_TYPE (boolean_false_node) = boolean_type_node;
6402   boolean_true_node = build_int_2 (1, 0);
6403   TREE_TYPE (boolean_true_node) = boolean_type_node;
6404
6405   signed_size_zero_node = build_int_2 (0, 0);
6406   record_builtin_type (RID_FLOAT, NULL_PTR, float_type_node);
6407   record_builtin_type (RID_DOUBLE, NULL_PTR, double_type_node);
6408   record_builtin_type (CP_RID_MAX, "long double", long_double_type_node);
6409
6410   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
6411                         complex_integer_type_node));
6412   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
6413                         complex_float_type_node));
6414   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),
6415                         complex_double_type_node));
6416   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
6417                         complex_long_double_type_node));
6418
6419   TREE_TYPE (signed_size_zero_node) = make_signed_type (TYPE_PRECISION (sizetype));
6420
6421   record_builtin_type (RID_VOID, NULL_PTR, void_type_node);
6422   void_list_node = build_tree_list (NULL_TREE, void_type_node);
6423   TREE_PARMLIST (void_list_node) = 1;
6424
6425   /* Used for expressions that do nothing, but are not errors.  */
6426   void_zero_node = build_int_2 (0, 0);
6427   TREE_TYPE (void_zero_node) = void_type_node;
6428
6429   string_type_node = build_pointer_type (char_type_node);
6430   const_string_type_node
6431     = build_pointer_type (build_qualified_type (char_type_node,
6432                                                 TYPE_QUAL_CONST));
6433   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6434 #if 0
6435   record_builtin_type (CP_RID_MAX, NULL_PTR, string_type_node);
6436 #endif
6437
6438   /* Make a type to be the domain of a few array types
6439      whose domains don't really matter.
6440      200 is small enough that it always fits in size_t.  */
6441   array_domain_type = build_index_type (build_int_2 (200, 0));
6442
6443   /* Make a type for arrays of characters.
6444      With luck nothing will ever really depend on the length of this
6445      array type.  */
6446   char_array_type_node
6447     = build_array_type (char_type_node, array_domain_type);
6448
6449   /* Likewise for arrays of ints.  */
6450   int_array_type_node
6451     = build_array_type (integer_type_node, array_domain_type);
6452
6453   if (flag_new_abi)
6454     delta_type_node = ptrdiff_type_node;
6455   else if (flag_huge_objects)
6456     delta_type_node = long_integer_type_node;
6457   else
6458     delta_type_node = short_integer_type_node;
6459
6460   if (flag_new_abi)
6461     vtable_index_type = ptrdiff_type_node;
6462   else
6463     vtable_index_type = delta_type_node;
6464
6465   default_function_type
6466     = build_function_type (integer_type_node, NULL_TREE);
6467
6468   ptr_type_node = build_pointer_type (void_type_node);
6469   const_ptr_type_node
6470     = build_pointer_type (build_qualified_type (void_type_node,
6471                                                 TYPE_QUAL_CONST));
6472   vtt_parm_type = build_pointer_type (const_ptr_type_node);
6473   c_common_nodes_and_builtins (1, flag_no_builtin, flag_no_nonansi_builtin);
6474   lang_type_promotes_to = convert_type_from_ellipsis;
6475
6476   void_ftype_ptr
6477     = build_exception_variant (void_ftype_ptr, empty_except_spec);
6478
6479   /* C++ extensions */
6480
6481   unknown_type_node = make_node (UNKNOWN_TYPE);
6482   record_unknown_type (unknown_type_node, "unknown type");
6483
6484   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
6485   TREE_TYPE (unknown_type_node) = unknown_type_node;
6486
6487   TREE_TYPE (null_node) = type_for_size (POINTER_SIZE, 0);
6488
6489   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6490      result.  */
6491   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6492   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6493
6494   /* This is special for C++ so functions can be overloaded.  */
6495   wchar_type_node = get_identifier (flag_short_wchar
6496                                     ? "short unsigned int"
6497                                     : WCHAR_TYPE);
6498   wchar_type_node = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (wchar_type_node));
6499   wchar_type_size = TYPE_PRECISION (wchar_type_node);
6500   if (TREE_UNSIGNED (wchar_type_node))
6501     wchar_type_node = make_signed_type (wchar_type_size);
6502   else
6503     wchar_type_node = make_unsigned_type (wchar_type_size);
6504   record_builtin_type (RID_WCHAR, "__wchar_t", wchar_type_node);
6505
6506   /* Artificial declaration of wchar_t -- can be bashed */
6507   wchar_decl_node = build_decl (TYPE_DECL, get_identifier ("wchar_t"),
6508                                 wchar_type_node);
6509   pushdecl (wchar_decl_node);
6510
6511   /* This is for wide string constants.  */
6512   wchar_array_type_node
6513     = build_array_type (wchar_type_node, array_domain_type);
6514
6515   if (flag_vtable_thunks)
6516     {
6517       /* Make sure we get a unique function type, so we can give
6518          its pointer type a name.  (This wins for gdb.) */
6519       tree vfunc_type = make_node (FUNCTION_TYPE);
6520       TREE_TYPE (vfunc_type) = integer_type_node;
6521       TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6522       layout_type (vfunc_type);
6523
6524       vtable_entry_type = build_pointer_type (vfunc_type);
6525     }
6526   else
6527     {
6528       vtable_entry_type = make_aggr_type (RECORD_TYPE);
6529       fields[0] = build_decl (FIELD_DECL, delta_identifier,
6530                               delta_type_node);
6531       fields[1] = build_decl (FIELD_DECL, index_identifier,
6532                               delta_type_node);
6533       fields[2] = build_decl (FIELD_DECL, pfn_identifier,
6534                               ptr_type_node);
6535       finish_builtin_type (vtable_entry_type, VTBL_PTR_TYPE, fields, 2,
6536                            double_type_node);
6537
6538       /* Make this part of an invisible union.  */
6539       fields[3] = copy_node (fields[2]);
6540       TREE_TYPE (fields[3]) = delta_type_node;
6541       DECL_NAME (fields[3]) = delta2_identifier;
6542       DECL_MODE (fields[3]) = TYPE_MODE (delta_type_node);
6543       DECL_SIZE (fields[3]) = TYPE_SIZE (delta_type_node);
6544       DECL_SIZE_UNIT (fields[3]) = TYPE_SIZE_UNIT (delta_type_node);
6545       TREE_UNSIGNED (fields[3]) = 0;
6546       TREE_CHAIN (fields[2]) = fields[3];
6547       vtable_entry_type = build_qualified_type (vtable_entry_type,
6548                                                 TYPE_QUAL_CONST);
6549     }
6550   record_builtin_type (CP_RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6551
6552   vtbl_type_node
6553     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6554   layout_type (vtbl_type_node);
6555   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6556   record_builtin_type (CP_RID_MAX, NULL_PTR, vtbl_type_node);
6557   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6558   layout_type (vtbl_ptr_type_node);
6559   record_builtin_type (CP_RID_MAX, NULL_PTR, vtbl_ptr_type_node);
6560
6561   std_node = build_decl (NAMESPACE_DECL,
6562                          flag_honor_std
6563                          ? get_identifier ("fake std") : std_identifier,
6564                          void_type_node);
6565   pushdecl (std_node);
6566
6567   if (flag_new_abi)
6568     {
6569       push_namespace (get_identifier ("__cxxabiv1"));
6570       abi_node = current_namespace;
6571       pop_namespace ();
6572     }
6573
6574   global_type_node = make_node (LANG_TYPE);
6575   record_unknown_type (global_type_node, "global type");
6576
6577   /* Now, C++.  */
6578   current_lang_name = lang_name_cplusplus;
6579
6580   {
6581     tree bad_alloc_type_node, newtype, deltype;
6582     if (flag_honor_std)
6583       push_namespace (get_identifier ("std"));
6584     bad_alloc_type_node = xref_tag
6585       (class_type_node, get_identifier ("bad_alloc"), 1);
6586     if (flag_honor_std)
6587       pop_namespace ();
6588     newtype = build_exception_variant
6589       (ptr_ftype_sizetype, add_exception_specifier (NULL_TREE, bad_alloc_type_node, -1));
6590     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6591     push_cp_library_fn (NEW_EXPR, newtype);
6592     push_cp_library_fn (VEC_NEW_EXPR, newtype);
6593     global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
6594     push_cp_library_fn (VEC_DELETE_EXPR, deltype);
6595   }
6596
6597   abort_fndecl
6598     = build_library_fn_ptr ("__pure_virtual", void_ftype);
6599
6600   /* Perform other language dependent initializations.  */
6601   init_class_processing ();
6602   init_init_processing ();
6603   init_search_processing ();
6604   init_rtti_processing ();
6605
6606   if (flag_exceptions)
6607     init_exception_processing ();
6608   if (flag_no_inline)
6609     {
6610       flag_inline_functions = 0;
6611     }
6612
6613   if (! supports_one_only ())
6614     flag_weak = 0;
6615
6616   /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__.  */
6617   make_fname_decl = cp_make_fname_decl;
6618   declare_function_name ();
6619
6620   /* Prepare to check format strings against argument lists.  */
6621   init_function_format_info ();
6622
6623   /* Show we use EH for cleanups.  */
6624   using_eh_for_cleanups ();
6625
6626   print_error_function = lang_print_error_function;
6627   valid_lang_attribute = cp_valid_lang_attribute;
6628
6629   /* Maintain consistency.  Perhaps we should just complain if they
6630      say -fwritable-strings?  */
6631   if (flag_writable_strings)
6632     flag_const_strings = 0;
6633
6634   /* Add GC roots for all of our global variables.  */
6635   ggc_add_tree_root (c_global_trees, sizeof c_global_trees / sizeof(tree));
6636   ggc_add_tree_root (cp_global_trees, sizeof cp_global_trees / sizeof(tree));
6637   ggc_add_tree_root (&integer_three_node, 1);
6638   ggc_add_tree_root (&integer_two_node, 1);
6639   ggc_add_tree_root (&signed_size_zero_node, 1);
6640   ggc_add_tree_root (&size_one_node, 1);
6641   ggc_add_tree_root (&size_zero_node, 1);
6642   ggc_add_root (&global_binding_level, 1, sizeof global_binding_level,
6643                 mark_binding_level);
6644   ggc_add_root (&scope_chain, 1, sizeof scope_chain, &mark_saved_scope);
6645   ggc_add_tree_root (&static_ctors, 1);
6646   ggc_add_tree_root (&static_dtors, 1);
6647   ggc_add_tree_root (&lastiddecl, 1);
6648
6649   ggc_add_tree_root (&last_function_parm_tags, 1);
6650   ggc_add_tree_root (&current_function_return_value, 1);
6651   ggc_add_tree_root (&current_function_parms, 1);
6652   ggc_add_tree_root (&current_function_parm_tags, 1);
6653   ggc_add_tree_root (&last_function_parms, 1);
6654   ggc_add_tree_root (&error_mark_list, 1);
6655
6656   ggc_add_tree_root (&global_namespace, 1);
6657   ggc_add_tree_root (&global_type_node, 1);
6658   ggc_add_tree_root (&anonymous_namespace_name, 1);
6659
6660   ggc_add_tree_root (&got_object, 1);
6661   ggc_add_tree_root (&got_scope, 1);
6662
6663   ggc_add_tree_root (&current_lang_name, 1);
6664   ggc_add_tree_root (&static_aggregates, 1);
6665 }
6666
6667 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6668    decl, NAME is the initialization string and TYPE_DEP indicates whether
6669    NAME depended on the type of the function. We make use of that to detect
6670    __PRETTY_FUNCTION__ inside a template fn.  Because we build a tree for
6671    the function before emitting any of it, we don't need to treat the
6672    VAR_DECL specially. We can decide whether to emit it later, if it was
6673    used.  */
6674
6675 static tree
6676 cp_make_fname_decl (id, name, type_dep)
6677      tree id;
6678      const char *name;
6679      int type_dep;
6680 {
6681   tree decl, type, init;
6682   size_t length = strlen (name);
6683   tree domain = NULL_TREE;
6684
6685   if (!processing_template_decl)
6686     type_dep = 0;
6687   if (!type_dep)
6688     domain = build_index_type (build_int_2 (length, 0));
6689
6690   type =  build_cplus_array_type
6691           (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
6692            domain);
6693
6694   decl = build_decl (VAR_DECL, id, type);
6695   TREE_STATIC (decl) = 1;
6696   TREE_READONLY (decl) = 1;
6697   DECL_SOURCE_LINE (decl) = 0;
6698   DECL_ARTIFICIAL (decl) = 1;
6699   DECL_IN_SYSTEM_HEADER (decl) = 1;
6700   pushdecl (decl);
6701   if (processing_template_decl)
6702     decl = push_template_decl (decl);
6703   if (type_dep)
6704     {
6705       init = build (FUNCTION_NAME, type);
6706       DECL_PRETTY_FUNCTION_P (decl) = 1;
6707     }
6708   else
6709     {
6710       init = build_string (length + 1, name);
6711       TREE_TYPE (init) = type;
6712     }
6713   DECL_INITIAL (decl) = init;
6714   cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
6715
6716   /* We will have to make sure we only emit this, if it is actually used. */
6717   return decl;
6718 }
6719
6720 /* Function to print any language-specific context for an error message.  */
6721
6722 static void
6723 lang_print_error_function (file)
6724      const char *file;
6725 {
6726   default_print_error_function (file);
6727   maybe_print_template_context ();
6728 }
6729
6730 /* Entry point for the benefit of c_common_nodes_and_builtins.
6731
6732    Make a definition for a builtin function named NAME and whose data type
6733    is TYPE.  TYPE should be a function type with argument types.
6734
6735    CLASS and CODE tell later passes how to compile calls to this function.
6736    See tree.h for possible values.
6737
6738    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6739    the name to be called if we can't opencode the function.  */
6740
6741 tree
6742 builtin_function (name, type, code, class, libname)
6743      const char *name;
6744      tree type;
6745      int code;
6746      enum built_in_class class;
6747      const char *libname;
6748 {
6749   tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
6750   DECL_BUILT_IN_CLASS (decl) = class;
6751   DECL_FUNCTION_CODE (decl) = code;
6752
6753   my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 392);
6754
6755   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6756      we cannot change DECL_ASSEMBLER_NAME until we have installed this
6757      function in the namespace.  */
6758   pushdecl (decl);
6759   if (libname)
6760     DECL_ASSEMBLER_NAME (decl) = get_identifier (libname);
6761   make_function_rtl (decl);
6762
6763   /* Warn if a function in the namespace for users
6764      is used without an occasion to consider it declared.  */
6765   if (name[0] != '_' || name[1] != '_')
6766     DECL_ANTICIPATED (decl) = 1;
6767
6768   return decl;
6769 }
6770
6771 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
6772    function.  Not called directly.  */
6773
6774 static tree
6775 build_library_fn_1 (name, operator_code, type)
6776      tree name;
6777      enum tree_code operator_code;
6778      tree type;
6779 {
6780   tree fn = build_lang_decl (FUNCTION_DECL, name, type);
6781   DECL_EXTERNAL (fn) = 1;
6782   TREE_PUBLIC (fn) = 1;
6783   DECL_ARTIFICIAL (fn) = 1;
6784   TREE_NOTHROW (fn) = 1;
6785   SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
6786   return fn;
6787 }
6788
6789 /* Returns the _DECL for a library function with C linkage.
6790    We assume that such functions never throw; if this is incorrect,
6791    callers should unset TREE_NOTHROW.  */
6792
6793 tree
6794 build_library_fn (name, type)
6795      tree name;
6796      tree type;
6797 {
6798   tree fn = build_library_fn_1 (name, ERROR_MARK, type);
6799   make_function_rtl (fn);
6800   return fn;
6801 }
6802
6803 /* Returns the _DECL for a library function with C++ linkage.  */
6804
6805 static tree
6806 build_cp_library_fn (name, operator_code, type)
6807      tree name;
6808      enum tree_code operator_code;
6809      tree type;
6810 {
6811   tree fn = build_library_fn_1 (name, operator_code, type);
6812   TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
6813   DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
6814   set_mangled_name_for_decl (fn);
6815   make_function_rtl (fn);
6816   return fn;
6817 }
6818
6819 /* Like build_library_fn, but takes a C string instead of an
6820    IDENTIFIER_NODE.  */
6821
6822 tree
6823 build_library_fn_ptr (name, type)
6824      const char *name;
6825      tree type;
6826 {
6827   return build_library_fn (get_identifier (name), type);
6828 }
6829
6830 /* Like build_cp_library_fn, but takes a C string instead of an
6831    IDENTIFIER_NODE.  */
6832
6833 tree
6834 build_cp_library_fn_ptr (name, type)
6835      const char *name;
6836      tree type;
6837 {
6838   return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
6839 }
6840
6841 /* Like build_library_fn, but also pushes the function so that we will
6842    be able to find it via IDENTIFIER_GLOBAL_VALUE.  */
6843
6844 tree
6845 push_library_fn (name, type)
6846      tree name, type;
6847 {
6848   tree fn = build_library_fn (name, type);
6849   pushdecl_top_level (fn);
6850   return fn;
6851 }
6852
6853 /* Like build_cp_library_fn, but also pushes the function so that it
6854    will be found by normal lookup.  */
6855
6856 static tree
6857 push_cp_library_fn (operator_code, type)
6858      enum tree_code operator_code;
6859      tree type;
6860 {
6861   tree fn = build_cp_library_fn (ansi_opname (operator_code),
6862                                  operator_code,
6863                                  type);
6864   pushdecl (fn);
6865   return fn;
6866 }
6867
6868 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
6869    a FUNCTION_TYPE.  */
6870
6871 tree
6872 push_void_library_fn (name, parmtypes)
6873      tree name, parmtypes;
6874 {
6875   tree type = build_function_type (void_type_node, parmtypes);
6876   return push_library_fn (name, type);
6877 }
6878
6879 /* Like push_library_fn, but also note that this function throws
6880    and does not return.  Used for __throw_foo and the like.  */
6881
6882 tree
6883 push_throw_library_fn (name, type)
6884      tree name, type;
6885 {
6886   tree fn = push_library_fn (name, type);
6887   TREE_THIS_VOLATILE (fn) = 1;
6888   TREE_NOTHROW (fn) = 0;
6889   return fn;
6890 }
6891 \f
6892 /* When we call finish_struct for an anonymous union, we create
6893    default copy constructors and such.  But, an anonymous union
6894    shouldn't have such things; this function undoes the damage to the
6895    anonymous union type T.
6896
6897    (The reason that we create the synthesized methods is that we don't
6898    distinguish `union { int i; }' from `typedef union { int i; } U'.
6899    The first is an anonymous union; the second is just an ordinary
6900    union type.)  */
6901
6902 void
6903 fixup_anonymous_aggr (t)
6904      tree t;
6905 {
6906   tree *q;
6907
6908   /* Wipe out memory of synthesized methods */
6909   TYPE_HAS_CONSTRUCTOR (t) = 0;
6910   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6911   TYPE_HAS_INIT_REF (t) = 0;
6912   TYPE_HAS_CONST_INIT_REF (t) = 0;
6913   TYPE_HAS_ASSIGN_REF (t) = 0;
6914   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6915
6916   /* Splice the implicitly generated functions out of the TYPE_METHODS
6917      list.  */
6918   q = &TYPE_METHODS (t);
6919   while (*q)
6920     {
6921       if (DECL_ARTIFICIAL (*q))
6922         *q = TREE_CHAIN (*q);
6923       else
6924         q = &TREE_CHAIN (*q);
6925     }
6926
6927   /* ISO C++ 9.5.3.  Anonymous unions may not have function members.  */
6928   if (TYPE_METHODS (t))
6929     error ("an anonymous union cannot have function members");
6930 }
6931
6932 /* Make sure that a declaration with no declarator is well-formed, i.e.
6933    just defines a tagged type or anonymous union.
6934
6935    Returns the type defined, if any.  */
6936
6937 tree
6938 check_tag_decl (declspecs)
6939      tree declspecs;
6940 {
6941   int found_type = 0;
6942   int saw_friend = 0;
6943   tree ob_modifier = NULL_TREE;
6944   register tree link;
6945   register tree t = NULL_TREE;
6946
6947   for (link = declspecs; link; link = TREE_CHAIN (link))
6948     {
6949       register tree value = TREE_VALUE (link);
6950
6951       if (TYPE_P (value)
6952           || (TREE_CODE (value) == IDENTIFIER_NODE
6953               && IDENTIFIER_GLOBAL_VALUE (value)
6954               && TYPE_P (IDENTIFIER_GLOBAL_VALUE (value))))
6955         {
6956           ++found_type;
6957
6958           if (IS_AGGR_TYPE (value) || TREE_CODE (value) == ENUMERAL_TYPE)
6959             {
6960               my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
6961               t = value;
6962             }
6963         }
6964       else if (value == ridpointers[(int) RID_FRIEND])
6965         {
6966           if (current_class_type == NULL_TREE
6967               || current_scope () != current_class_type)
6968             ob_modifier = value;
6969           else
6970             saw_friend = 1;
6971         }
6972       else if (value == ridpointers[(int) RID_STATIC]
6973                || value == ridpointers[(int) RID_EXTERN]
6974                || value == ridpointers[(int) RID_AUTO]
6975                || value == ridpointers[(int) RID_REGISTER]
6976                || value == ridpointers[(int) RID_INLINE]
6977                || value == ridpointers[(int) RID_VIRTUAL]
6978                || value == ridpointers[(int) RID_CONST]
6979                || value == ridpointers[(int) RID_VOLATILE]
6980                || value == ridpointers[(int) RID_EXPLICIT])
6981         ob_modifier = value;
6982     }
6983
6984   if (found_type > 1)
6985     error ("multiple types in one declaration");
6986
6987   if (t == NULL_TREE && ! saw_friend)
6988     pedwarn ("declaration does not declare anything");
6989
6990   /* Check for an anonymous union.  We're careful
6991      accessing TYPE_IDENTIFIER because some built-in types, like
6992      pointer-to-member types, do not have TYPE_NAME.  */
6993   else if (t && IS_AGGR_TYPE_CODE (TREE_CODE (t))
6994            && TYPE_NAME (t)
6995            && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
6996     {
6997       /* Anonymous unions are objects, so they can have specifiers.  */;
6998       SET_ANON_AGGR_TYPE_P (t);
6999
7000       if (TREE_CODE (t) != UNION_TYPE && pedantic && ! in_system_header)
7001         pedwarn ("ISO C++ prohibits anonymous structs");
7002     }
7003
7004   else if (ob_modifier)
7005     {
7006       if (ob_modifier == ridpointers[(int) RID_INLINE]
7007           || ob_modifier == ridpointers[(int) RID_VIRTUAL])
7008         cp_error ("`%D' can only be specified for functions", ob_modifier);
7009       else if (ob_modifier == ridpointers[(int) RID_FRIEND])
7010         cp_error ("`%D' can only be specified inside a class", ob_modifier);
7011       else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
7012         cp_error ("`%D' can only be specified for constructors",
7013                   ob_modifier);
7014       else
7015         cp_error ("`%D' can only be specified for objects and functions",
7016                   ob_modifier);
7017     }
7018
7019   return t;
7020 }
7021
7022 /* Called when a declaration is seen that contains no names to declare.
7023    If its type is a reference to a structure, union or enum inherited
7024    from a containing scope, shadow that tag name for the current scope
7025    with a forward reference.
7026    If its type defines a new named structure or union
7027    or defines an enum, it is valid but we need not do anything here.
7028    Otherwise, it is an error.
7029
7030    C++: may have to grok the declspecs to learn about static,
7031    complain for anonymous unions.  */
7032
7033 void
7034 shadow_tag (declspecs)
7035      tree declspecs;
7036 {
7037   tree t = check_tag_decl (declspecs);
7038
7039   if (t)
7040     maybe_process_partial_specialization (t);
7041
7042   /* This is where the variables in an anonymous union are
7043      declared.  An anonymous union declaration looks like:
7044      union { ... } ;
7045      because there is no declarator after the union, the parser
7046      sends that declaration here.  */
7047   if (t && ANON_AGGR_TYPE_P (t))
7048     {
7049       fixup_anonymous_aggr (t);
7050
7051       if (TYPE_FIELDS (t))
7052         {
7053           tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
7054                                       NULL_TREE);
7055           finish_anon_union (decl);
7056         }
7057     }
7058 }
7059 \f
7060 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
7061
7062 tree
7063 groktypename (typename)
7064      tree typename;
7065 {
7066   if (TREE_CODE (typename) != TREE_LIST)
7067     return typename;
7068   return grokdeclarator (TREE_VALUE (typename),
7069                          TREE_PURPOSE (typename),
7070                          TYPENAME, 0, NULL_TREE);
7071 }
7072
7073 /* Decode a declarator in an ordinary declaration or data definition.
7074    This is called as soon as the type information and variable name
7075    have been parsed, before parsing the initializer if any.
7076    Here we create the ..._DECL node, fill in its type,
7077    and put it on the list of decls for the current context.
7078    The ..._DECL node is returned as the value.
7079
7080    Exception: for arrays where the length is not specified,
7081    the type is left null, to be filled in by `cp_finish_decl'.
7082
7083    Function definitions do not come here; they go to start_function
7084    instead.  However, external and forward declarations of functions
7085    do go through here.  Structure field declarations are done by
7086    grokfield and not through here.  */
7087
7088 tree
7089 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
7090      tree declarator, declspecs;
7091      int initialized;
7092      tree attributes, prefix_attributes;
7093 {
7094   register tree decl;
7095   register tree type, tem;
7096   tree context;
7097   extern int have_extern_spec;
7098   extern int used_extern_spec;
7099   tree attrlist;
7100
7101 #if 0
7102   /* See code below that used this.  */
7103   int init_written = initialized;
7104 #endif
7105
7106   /* This should only be done once on the top most decl.  */
7107   if (have_extern_spec && !used_extern_spec)
7108     {
7109       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"),
7110                                   declspecs);
7111       used_extern_spec = 1;
7112     }
7113
7114   if (attributes || prefix_attributes)
7115     attrlist = build_tree_list (attributes, prefix_attributes);
7116   else
7117     attrlist = NULL_TREE;
7118
7119   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
7120                          attrlist);
7121
7122   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
7123     return NULL_TREE;
7124
7125   type = TREE_TYPE (decl);
7126
7127   if (type == error_mark_node)
7128     return NULL_TREE;
7129
7130   context = DECL_CONTEXT (decl);
7131
7132   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
7133       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
7134     {
7135       /* When parsing the initializer, lookup should use the object's
7136          namespace. */
7137       push_decl_namespace (context);
7138     }
7139
7140   /* We are only interested in class contexts, later. */
7141   if (context && TREE_CODE (context) == NAMESPACE_DECL)
7142     context = NULL_TREE;
7143
7144   if (initialized)
7145     /* Is it valid for this decl to have an initializer at all?
7146        If not, set INITIALIZED to zero, which will indirectly
7147        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7148     switch (TREE_CODE (decl))
7149       {
7150       case TYPE_DECL:
7151         /* typedef foo = bar  means give foo the same type as bar.
7152            We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
7153            Any other case of an initialization in a TYPE_DECL is an error.  */
7154         if (pedantic || list_length (declspecs) > 1)
7155           {
7156             cp_error ("typedef `%D' is initialized", decl);
7157             initialized = 0;
7158           }
7159         break;
7160
7161       case FUNCTION_DECL:
7162         cp_error ("function `%#D' is initialized like a variable", decl);
7163         initialized = 0;
7164         break;
7165
7166       default:
7167         break;
7168       }
7169
7170   if (initialized)
7171     {
7172       if (! toplevel_bindings_p ()
7173           && DECL_EXTERNAL (decl))
7174         cp_warning ("declaration of `%#D' has `extern' and is initialized",
7175                     decl);
7176       DECL_EXTERNAL (decl) = 0;
7177       if (toplevel_bindings_p ())
7178         TREE_STATIC (decl) = 1;
7179
7180       /* Tell `pushdecl' this is an initialized decl
7181          even though we don't yet have the initializer expression.
7182          Also tell `cp_finish_decl' it may store the real initializer.  */
7183       DECL_INITIAL (decl) = error_mark_node;
7184     }
7185
7186 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
7187   SET_DEFAULT_DECL_ATTRIBUTES (decl, attributes);
7188 #endif
7189
7190   /* Set attributes here so if duplicate decl, will have proper attributes.  */
7191   cplus_decl_attributes (decl, attributes, prefix_attributes);
7192
7193   if (context && COMPLETE_TYPE_P (complete_type (context)))
7194     {
7195       push_nested_class (context, 2);
7196
7197       if (TREE_CODE (decl) == VAR_DECL)
7198         {
7199           tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
7200           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
7201             cp_error ("`%#D' is not a static member of `%#T'", decl, context);
7202           else
7203             {
7204               if (DECL_CONTEXT (field) != context)
7205                 {
7206                   cp_pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
7207                               DECL_CONTEXT (field), DECL_NAME (decl),
7208                               context, DECL_NAME (decl));
7209                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
7210                 }
7211               /* Static data member are tricky; an in-class initialization
7212                  still doesn't provide a definition, so the in-class
7213                  declaration will have DECL_EXTERNAL set, but will have an
7214                  initialization.  Thus, duplicate_decls won't warn
7215                  about this situation, and so we check here.  */
7216               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
7217                 cp_error ("duplicate initialization of %D", decl);
7218               if (duplicate_decls (decl, field))
7219                 decl = field;
7220             }
7221         }
7222       else
7223         {
7224           tree field = check_classfn (context, decl);
7225           if (field && duplicate_decls (decl, field))
7226             decl = field;
7227         }
7228
7229       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
7230       DECL_IN_AGGR_P (decl) = 0;
7231       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
7232           || CLASSTYPE_TEMPLATE_INSTANTIATION (context))
7233         {
7234           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
7235           /* [temp.expl.spec] An explicit specialization of a static data
7236              member of a template is a definition if the declaration
7237              includes an initializer; otherwise, it is a declaration.
7238
7239              We check for processing_specialization so this only applies
7240              to the new specialization syntax.  */
7241           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
7242             DECL_EXTERNAL (decl) = 1;
7243         }
7244
7245       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
7246         cp_pedwarn ("declaration of `%#D' outside of class is not definition",
7247                     decl);
7248     }
7249
7250   /* Enter this declaration into the symbol table.  */
7251   tem = maybe_push_decl (decl);
7252
7253   if (processing_template_decl)
7254     tem = push_template_decl (tem);
7255
7256 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7257   /* Tell the back-end to use or not use .common as appropriate.  If we say
7258      -fconserve-space, we want this to save .data space, at the expense of
7259      wrong semantics.  If we say -fno-conserve-space, we want this to
7260      produce errors about redefs; to do this we force variables into the
7261      data segment.  */
7262   DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
7263 #endif
7264
7265   if (! processing_template_decl)
7266     start_decl_1 (tem);
7267
7268   return tem;
7269 }
7270
7271 void
7272 start_decl_1 (decl)
7273      tree decl;
7274 {
7275   tree type = TREE_TYPE (decl);
7276   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
7277
7278   if (type == error_mark_node)
7279     return;
7280
7281   /* If this type of object needs a cleanup, but we're not allowed to
7282      add any more objects with cleanups to the current scope, create a
7283      new binding level.  */
7284   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
7285       && current_binding_level->more_cleanups_ok == 0)
7286     {
7287       keep_next_level (2);
7288       pushlevel (1);
7289       clear_last_expr ();
7290       add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
7291     }
7292
7293   if (initialized)
7294     /* Is it valid for this decl to have an initializer at all?
7295        If not, set INITIALIZED to zero, which will indirectly
7296        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7297     {
7298       /* Don't allow initializations for incomplete types except for
7299          arrays which might be completed by the initialization.  */
7300       if (COMPLETE_TYPE_P (complete_type (type)))
7301         ;                       /* A complete type is ok.  */
7302       else if (TREE_CODE (type) != ARRAY_TYPE)
7303         {
7304           cp_error ("variable `%#D' has initializer but incomplete type",
7305                     decl);
7306           initialized = 0;
7307           type = TREE_TYPE (decl) = error_mark_node;
7308         }
7309       else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7310         {
7311           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
7312             cp_error ("elements of array `%#D' have incomplete type", decl);
7313           /* else we already gave an error in start_decl.  */
7314           initialized = 0;
7315         }
7316     }
7317
7318   if (!initialized
7319       && TREE_CODE (decl) != TYPE_DECL
7320       && TREE_CODE (decl) != TEMPLATE_DECL
7321       && type != error_mark_node
7322       && IS_AGGR_TYPE (type)
7323       && ! DECL_EXTERNAL (decl))
7324     {
7325       if ((! processing_template_decl || ! uses_template_parms (type))
7326           && !COMPLETE_TYPE_P (complete_type (type)))
7327         {
7328           cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
7329                  decl);
7330           /* Change the type so that assemble_variable will give
7331              DECL an rtl we can live with: (mem (const_int 0)).  */
7332           type = TREE_TYPE (decl) = error_mark_node;
7333         }
7334       else
7335         {
7336           /* If any base type in the hierarchy of TYPE needs a constructor,
7337              then we set initialized to 1.  This way any nodes which are
7338              created for the purposes of initializing this aggregate
7339              will live as long as it does.  This is necessary for global
7340              aggregates which do not have their initializers processed until
7341              the end of the file.  */
7342           initialized = TYPE_NEEDS_CONSTRUCTING (type);
7343         }
7344     }
7345
7346   if (! initialized)
7347     DECL_INITIAL (decl) = NULL_TREE;
7348 }
7349
7350 /* Handle initialization of references.
7351    These three arguments are from `cp_finish_decl', and have the
7352    same meaning here that they do there.
7353
7354    Quotes on semantics can be found in ARM 8.4.3.  */
7355
7356 static void
7357 grok_reference_init (decl, type, init)
7358      tree decl, type, init;
7359 {
7360   tree tmp;
7361
7362   if (init == NULL_TREE)
7363     {
7364       if ((DECL_LANG_SPECIFIC (decl) == 0
7365            || DECL_IN_AGGR_P (decl) == 0)
7366           && ! DECL_THIS_EXTERN (decl))
7367         cp_error ("`%D' declared as reference but not initialized", decl);
7368       return;
7369     }
7370
7371   if (init == error_mark_node)
7372     return;
7373
7374   if (TREE_CODE (init) == CONSTRUCTOR)
7375     {
7376       cp_error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
7377       return;
7378     }
7379
7380   if (TREE_CODE (init) == TREE_LIST)
7381     init = build_compound_expr (init);
7382
7383   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
7384     init = convert_from_reference (init);
7385
7386   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
7387       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
7388     {
7389       /* Note: default conversion is only called in very special cases.  */
7390       init = default_conversion (init);
7391     }
7392
7393   /* Convert INIT to the reference type TYPE.  This may involve the
7394      creation of a temporary, whose lifetime must be the same as that
7395      of the reference.  If so, a DECL_STMT for the temporary will be
7396      added just after the DECL_STMT for DECL.  That's why we don't set
7397      DECL_INITIAL for local references (instead assigning to them
7398      explicitly); we need to allow the temporary to be initialized
7399      first.  */
7400   tmp = convert_to_reference
7401     (type, init, CONV_IMPLICIT,
7402      LOOKUP_ONLYCONVERTING|LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND,
7403      decl);
7404
7405   if (tmp == error_mark_node)
7406     return;
7407   else if (tmp != NULL_TREE)
7408     {
7409       init = tmp;
7410       tmp = save_expr (tmp);
7411       if (building_stmt_tree ())
7412         {
7413           /* Initialize the declaration.  */
7414           tmp = build (INIT_EXPR, TREE_TYPE (decl), decl, tmp);
7415           finish_expr_stmt (tmp);
7416         }
7417       else
7418         DECL_INITIAL (decl) = tmp;
7419     }
7420   else
7421     {
7422       cp_error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
7423       return;
7424     }
7425
7426   if (TREE_STATIC (decl) && ! TREE_CONSTANT (DECL_INITIAL (decl)))
7427     {
7428       expand_static_init (decl, DECL_INITIAL (decl));
7429       DECL_INITIAL (decl) = NULL_TREE;
7430     }
7431   return;
7432 }
7433
7434 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7435    mucking with forces it does not comprehend (i.e. initialization with a
7436    constructor).  If we are at global scope and won't go into COMMON, fill
7437    it in with a dummy CONSTRUCTOR to force the variable into .data;
7438    otherwise we can use error_mark_node.  */
7439
7440 static tree
7441 obscure_complex_init (decl, init)
7442      tree decl, init;
7443 {
7444   if (! flag_no_inline && TREE_STATIC (decl))
7445     {
7446       if (extract_init (decl, init))
7447         return NULL_TREE;
7448     }
7449
7450 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7451   if (toplevel_bindings_p () && ! DECL_COMMON (decl))
7452     DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
7453                                  NULL_TREE);
7454   else
7455 #endif
7456     DECL_INITIAL (decl) = error_mark_node;
7457
7458   return init;
7459 }
7460
7461 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7462    array until we finish parsing the initializer.  If that's the
7463    situation we're in, update DECL accordingly.  */
7464
7465 static void
7466 maybe_deduce_size_from_array_init (decl, init)
7467      tree decl;
7468      tree init;
7469 {
7470   tree type = TREE_TYPE (decl);
7471
7472   if (TREE_CODE (type) == ARRAY_TYPE
7473       && TYPE_DOMAIN (type) == NULL_TREE
7474       && TREE_CODE (decl) != TYPE_DECL)
7475     {
7476       int do_default
7477         = (TREE_STATIC (decl)
7478            /* Even if pedantic, an external linkage array
7479               may have incomplete type at first.  */
7480            ? pedantic && ! DECL_EXTERNAL (decl)
7481            : !DECL_EXTERNAL (decl));
7482       tree initializer = init ? init : DECL_INITIAL (decl);
7483       int failure = complete_array_type (type, initializer, do_default);
7484
7485       if (failure == 1)
7486         cp_error ("initializer fails to determine size of `%D'", decl);
7487
7488       if (failure == 2)
7489         {
7490           if (do_default)
7491             cp_error ("array size missing in `%D'", decl);
7492           /* If a `static' var's size isn't known, make it extern as
7493              well as static, so it does not get allocated.  If it's not
7494              `static', then don't mark it extern; finish_incomplete_decl
7495              will give it a default size and it will get allocated.  */
7496           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7497             DECL_EXTERNAL (decl) = 1;
7498         }
7499
7500       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7501           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7502                               integer_zero_node))
7503         cp_error ("zero-size array `%D'", decl);
7504
7505       layout_decl (decl, 0);
7506     }
7507 }
7508
7509 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7510    any appropriate error messages regarding the layout.  */
7511
7512 static void
7513 layout_var_decl (decl)
7514      tree decl;
7515 {
7516   tree type = TREE_TYPE (decl);
7517 #if 0
7518   tree ttype = target_type (type);
7519 #endif
7520
7521   /* If we haven't already layed out this declaration, do so now.
7522      Note that we must not call complete type for an external object
7523      because it's type might involve templates that we are not
7524      supposed to isntantiate yet.  (And it's perfectly legal to say
7525      `extern X x' for some incomplete type `X'.)  */
7526   if (!DECL_EXTERNAL (decl))
7527     complete_type (type);
7528   if (!DECL_SIZE (decl) && COMPLETE_TYPE_P (type))
7529     layout_decl (decl, 0);
7530
7531   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7532     {
7533       /* An automatic variable with an incomplete type: that is an error.
7534          Don't talk about array types here, since we took care of that
7535          message in grokdeclarator.  */
7536       cp_error ("storage size of `%D' isn't known", decl);
7537       TREE_TYPE (decl) = error_mark_node;
7538     }
7539 #if 0
7540   /* Keep this code around in case we later want to control debug info
7541      based on whether a type is "used".  (jason 1999-11-11) */
7542
7543   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7544     /* Let debugger know it should output info for this type.  */
7545     note_debug_info_needed (ttype);
7546
7547   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7548     note_debug_info_needed (DECL_CONTEXT (decl));
7549 #endif
7550
7551   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7552       && DECL_SIZE (decl) != NULL_TREE
7553       && ! TREE_CONSTANT (DECL_SIZE (decl)))
7554     {
7555       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7556         constant_expression_warning (DECL_SIZE (decl));
7557       else
7558         cp_error ("storage size of `%D' isn't constant", decl);
7559     }
7560 }
7561
7562 /* If a local static variable is declared in an inline function, or if
7563    we have a weak definition, we must endeavor to create only one
7564    instance of the variable at link-time.  */
7565
7566 static void
7567 maybe_commonize_var (decl)
7568      tree decl;
7569 {
7570   /* Static data in a function with comdat linkage also has comdat
7571      linkage.  */
7572   if (TREE_STATIC (decl)
7573       /* Don't mess with __FUNCTION__.  */
7574       && ! DECL_ARTIFICIAL (decl)
7575       && current_function_decl
7576       && DECL_CONTEXT (decl) == current_function_decl
7577       && (DECL_THIS_INLINE (current_function_decl)
7578           || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7579       && TREE_PUBLIC (current_function_decl))
7580     {
7581       /* Rather than try to get this right with inlining, we suppress
7582          inlining of such functions.  */
7583       current_function_cannot_inline
7584         = "function with static variable cannot be inline";
7585
7586       /* If flag_weak, we don't need to mess with this, as we can just
7587          make the function weak, and let it refer to its unique local
7588          copy.  This works because we don't allow the function to be
7589          inlined.  */
7590       if (! flag_weak)
7591         {
7592           if (DECL_INTERFACE_KNOWN (current_function_decl))
7593             {
7594               TREE_PUBLIC (decl) = 1;
7595               DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7596             }
7597           else if (DECL_INITIAL (decl) == NULL_TREE
7598                    || DECL_INITIAL (decl) == error_mark_node)
7599             {
7600               TREE_PUBLIC (decl) = 1;
7601               DECL_COMMON (decl) = 1;
7602             }
7603           /* else we lose. We can only do this if we can use common,
7604              which we can't if it has been initialized.  */
7605
7606           if (TREE_PUBLIC (decl))
7607             DECL_ASSEMBLER_NAME (decl)
7608               = build_static_name (current_function_decl, DECL_NAME (decl));
7609           else
7610             {
7611               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7612               cp_warning_at ("  you can work around this by removing the initializer", decl);
7613             }
7614         }
7615     }
7616   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7617     /* Set it up again; we might have set DECL_INITIAL since the last
7618        time.  */
7619     comdat_linkage (decl);
7620 }
7621
7622 /* Issue an error message if DECL is an uninitialized const variable.  */
7623
7624 static void
7625 check_for_uninitialized_const_var (decl)
7626      tree decl;
7627 {
7628   tree type = TREE_TYPE (decl);
7629
7630   /* ``Unless explicitly declared extern, a const object does not have
7631      external linkage and must be initialized. ($8.4; $12.1)'' ARM
7632      7.1.6 */
7633   if (TREE_CODE (decl) == VAR_DECL
7634       && TREE_CODE (type) != REFERENCE_TYPE
7635       && CP_TYPE_CONST_P (type)
7636       && !TYPE_NEEDS_CONSTRUCTING (type)
7637       && !DECL_INITIAL (decl))
7638     cp_error ("uninitialized const `%D'", decl);
7639 }
7640
7641 /* Verify INIT (the initializer for DECL), and record the
7642    initialization in DECL_INITIAL, if appropriate.  Returns a new
7643    value for INIT.  */
7644
7645 static tree
7646 check_initializer (decl, init)
7647      tree decl;
7648      tree init;
7649 {
7650   tree type;
7651
7652   if (TREE_CODE (decl) == FIELD_DECL)
7653     return init;
7654
7655   type = TREE_TYPE (decl);
7656
7657   /* If `start_decl' didn't like having an initialization, ignore it now.  */
7658   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7659     init = NULL_TREE;
7660
7661   /* Check the initializer.  */
7662   if (init)
7663     {
7664       /* Things that are going to be initialized need to have complete
7665          type.  */
7666       TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7667
7668       if (type == error_mark_node)
7669         /* We will have already complained.  */
7670         init = NULL_TREE;
7671       else if (COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
7672         {
7673           cp_error ("variable-sized object `%D' may not be initialized", decl);
7674           init = NULL_TREE;
7675         }
7676       else if (TREE_CODE (type) == ARRAY_TYPE
7677                && !COMPLETE_TYPE_P (TREE_TYPE (type)))
7678         {
7679           cp_error ("elements of array `%#D' have incomplete type", decl);
7680           init = NULL_TREE;
7681         }
7682       else if (!COMPLETE_TYPE_P (type))
7683         {
7684           cp_error ("`%D' has incomplete type", decl);
7685           TREE_TYPE (decl) = error_mark_node;
7686           init = NULL_TREE;
7687         }
7688     }
7689
7690   if (TREE_CODE (decl) == CONST_DECL)
7691     {
7692       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7693
7694       DECL_INITIAL (decl) = init;
7695
7696       /* This will keep us from needing to worry about our obstacks.  */
7697       my_friendly_assert (init != NULL_TREE, 149);
7698       init = NULL_TREE;
7699     }
7700   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7701     {
7702       if (TREE_STATIC (decl))
7703         make_decl_rtl (decl, NULL_PTR, toplevel_bindings_p ());
7704       grok_reference_init (decl, type, init);
7705       init = NULL_TREE;
7706     }
7707   else if (init)
7708     {
7709       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7710         {
7711           if (TREE_CODE (type) == ARRAY_TYPE)
7712             init = digest_init (type, init, (tree *) 0);
7713           else if (TREE_CODE (init) == CONSTRUCTOR
7714                    && TREE_HAS_CONSTRUCTOR (init))
7715             {
7716               if (TYPE_NON_AGGREGATE_CLASS (type))
7717                 {
7718                   cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7719                             decl);
7720                   init = error_mark_node;
7721                 }
7722               else
7723                 goto dont_use_constructor;
7724             }
7725         }
7726       else
7727         {
7728         dont_use_constructor:
7729           if (TREE_CODE (init) != TREE_VEC)
7730             init = store_init_value (decl, init);
7731         }
7732
7733       if (init)
7734         /* We must hide the initializer so that expand_decl
7735            won't try to do something it does not understand.  */
7736         init = obscure_complex_init (decl, init);
7737     }
7738   else if (DECL_EXTERNAL (decl))
7739     ;
7740   else if (TYPE_P (type)
7741            && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
7742     {
7743       tree core_type = strip_array_types (type);
7744
7745       if (! TYPE_NEEDS_CONSTRUCTING (core_type))
7746         {
7747           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
7748             cp_error ("structure `%D' with uninitialized const members", decl);
7749           if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
7750             cp_error ("structure `%D' with uninitialized reference members",
7751                       decl);
7752         }
7753
7754       check_for_uninitialized_const_var (decl);
7755
7756       if (COMPLETE_TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
7757         init = obscure_complex_init (decl, NULL_TREE);
7758
7759     }
7760   else
7761     check_for_uninitialized_const_var (decl);
7762
7763   return init;
7764 }
7765
7766 /* If DECL is not a local variable, give it RTL.  */
7767
7768 static void
7769 make_rtl_for_nonlocal_decl (decl, init, asmspec)
7770      tree decl;
7771      tree init;
7772      const char *asmspec;
7773 {
7774   int toplev = toplevel_bindings_p ();
7775   int defer_p;
7776
7777   /* Handle non-variables up front.  */
7778   if (TREE_CODE (decl) != VAR_DECL)
7779     {
7780       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7781       return;
7782     }
7783
7784   /* If we see a class member here, it should be a static data
7785      member.  */
7786   if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
7787     {
7788       my_friendly_assert (TREE_STATIC (decl), 19990828);
7789       /* An in-class declaration of a static data member should be
7790          external; it is only a declaration, and not a definition.  */
7791       if (init == NULL_TREE)
7792         my_friendly_assert (DECL_EXTERNAL (decl), 20000723);
7793     }
7794
7795   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
7796   if (asmspec)
7797     DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
7798
7799   /* We don't create any RTL for local variables.  */
7800   if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
7801     return;
7802
7803   /* We defer emission of local statics until the corresponding
7804      DECL_STMT is expanded.  */
7805   defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
7806
7807   /* We try to defer namespace-scope static constants so that they are
7808      not emitted into the object file unncessarily.  */
7809   if (!DECL_VIRTUAL_P (decl)
7810       && TREE_READONLY (decl)
7811       && DECL_INITIAL (decl) != NULL_TREE
7812       && DECL_INITIAL (decl) != error_mark_node
7813       && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
7814       && toplev
7815       && !TREE_PUBLIC (decl))
7816     {
7817       /* Fool with the linkage according to #pragma interface.  */
7818       if (!interface_unknown)
7819         {
7820           TREE_PUBLIC (decl) = 1;
7821           DECL_EXTERNAL (decl) = interface_only;
7822         }
7823
7824       defer_p = 1;
7825     }
7826
7827   /* If we're deferring the variable, just make RTL.  Do not actually
7828      emit the variable.  */
7829   if (defer_p)
7830     make_decl_rtl (decl, asmspec, toplev);
7831   /* If we're not deferring, go ahead and assemble the variable.  */
7832   else
7833     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7834 }
7835
7836 /* The old ARM scoping rules injected variables declared in the
7837    initialization statement of a for-statement into the surrounding
7838    scope.  We support this usage, in order to be backward-compatible.
7839    DECL is a just-declared VAR_DECL; if necessary inject its
7840    declaration into the surrounding scope.  */
7841
7842 void
7843 maybe_inject_for_scope_var (decl)
7844      tree decl;
7845 {
7846   if (current_binding_level->is_for_scope)
7847     {
7848       struct binding_level *outer
7849         = current_binding_level->level_chain;
7850
7851       /* Check to see if the same name is already bound at the outer
7852          level, either because it was directly declared, or because a
7853          dead for-decl got preserved.  In either case, the code would
7854          not have been valid under the ARM scope rules, so clear
7855          is_for_scope for the current_binding_level.
7856
7857          Otherwise, we need to preserve the temp slot for decl to last
7858          into the outer binding level.  */
7859
7860       tree outer_binding
7861         = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
7862
7863       if (outer_binding && BINDING_LEVEL (outer_binding) == outer
7864           && (TREE_CODE (BINDING_VALUE (outer_binding))
7865               == VAR_DECL)
7866           && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
7867         {
7868           BINDING_VALUE (outer_binding)
7869             = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
7870           current_binding_level->is_for_scope = 0;
7871         }
7872       else if (DECL_IN_MEMORY_P (decl))
7873         preserve_temp_slots (DECL_RTL (decl));
7874     }
7875 }
7876
7877 /* Generate code to initialize DECL (a local variable).  */
7878
7879 void
7880 initialize_local_var (decl, init, flags)
7881      tree decl;
7882      tree init;
7883      int flags;
7884 {
7885   tree type = TREE_TYPE (decl);
7886
7887   /* If the type is bogus, don't bother initializing the variable.  */
7888   if (type == error_mark_node)
7889     return;
7890
7891   if (DECL_SIZE (decl) == NULL_TREE && !TREE_STATIC (decl))
7892     {
7893       /* If we used it already as memory, it must stay in memory.  */
7894       DECL_INITIAL (decl) = NULL_TREE;
7895       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
7896     }
7897
7898   /* Local statics are handled differently from ordinary automatic
7899      variables.  */
7900   if (TREE_STATIC (decl))
7901     {
7902       if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7903           || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7904         expand_static_init (decl, init);
7905       return;
7906     }
7907
7908   if (DECL_SIZE (decl) && type != error_mark_node)
7909     {
7910       int already_used;
7911
7912       /* Compute and store the initial value.  */
7913       already_used = TREE_USED (decl) || TREE_USED (type);
7914
7915       if (init || TYPE_NEEDS_CONSTRUCTING (type))
7916         {
7917           int saved_stmts_are_full_exprs_p;
7918
7919           emit_line_note (DECL_SOURCE_FILE (decl),
7920                           DECL_SOURCE_LINE (decl));
7921           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
7922           current_stmt_tree->stmts_are_full_exprs_p = 1;
7923           if (building_stmt_tree ())
7924             finish_expr_stmt (build_aggr_init (decl, init, flags));
7925           else
7926             genrtl_expr_stmt (build_aggr_init (decl, init, flags));
7927           current_stmt_tree->stmts_are_full_exprs_p = saved_stmts_are_full_exprs_p;
7928         }
7929
7930       /* Set this to 0 so we can tell whether an aggregate which was
7931          initialized was ever used.  Don't do this if it has a
7932          destructor, so we don't complain about the 'resource
7933          allocation is initialization' idiom.  Now set
7934          attribute((unused)) on types so decls of that type will be
7935          marked used. (see TREE_USED, above.)  */
7936       if (TYPE_NEEDS_CONSTRUCTING (type)
7937           && ! already_used
7938           && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
7939           && DECL_NAME (decl))
7940         TREE_USED (decl) = 0;
7941       else if (already_used)
7942         TREE_USED (decl) = 1;
7943     }
7944 }
7945
7946 /* Generate code to destroy DECL (a local variable).  */
7947
7948 static void
7949 destroy_local_var (decl)
7950      tree decl;
7951 {
7952   tree type = TREE_TYPE (decl);
7953   tree cleanup;
7954
7955   /* Only variables get cleaned up.  */
7956   if (TREE_CODE (decl) != VAR_DECL)
7957     return;
7958
7959   /* And only things with destructors need cleaning up.  */
7960   if (type == error_mark_node
7961       || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
7962     return;
7963
7964   if (TREE_CODE (decl) == VAR_DECL &&
7965       (DECL_EXTERNAL (decl) || TREE_STATIC (decl)))
7966     /* We don't clean up things that aren't defined in this
7967        translation unit, or that need a static cleanup.  The latter
7968        are handled by finish_file.  */
7969     return;
7970
7971   /* Compute the cleanup.  */
7972   cleanup = maybe_build_cleanup (decl);
7973
7974   /* Record the cleanup required for this declaration.  */
7975   if (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node
7976       && cleanup)
7977     finish_decl_cleanup (decl, cleanup);
7978 }
7979
7980 /* Finish processing of a declaration;
7981    install its line number and initial value.
7982    If the length of an array type is not known before,
7983    it must be determined now, from the initial value, or it is an error.
7984
7985    INIT0 holds the value of an initializer that should be allowed to escape
7986    the normal rules.
7987
7988    FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
7989    if the (init) syntax was used.  */
7990
7991 void
7992 cp_finish_decl (decl, init, asmspec_tree, flags)
7993      tree decl, init;
7994      tree asmspec_tree;
7995      int flags;
7996 {
7997   register tree type;
7998   tree ttype = NULL_TREE;
7999   const char *asmspec = NULL;
8000   int was_readonly = 0;
8001
8002   if (! decl)
8003     {
8004       if (init)
8005         error ("assignment (not initialization) in declaration");
8006       return;
8007     }
8008
8009   /* If a name was specified, get the string.  */
8010   if (asmspec_tree)
8011       asmspec = TREE_STRING_POINTER (asmspec_tree);
8012
8013   if (init && TREE_CODE (init) == NAMESPACE_DECL)
8014     {
8015       cp_error ("cannot initialize `%D' to namespace `%D'",
8016                 decl, init);
8017       init = NULL_TREE;
8018     }
8019
8020   if (current_class_type
8021       && CP_DECL_CONTEXT (decl) == current_class_type
8022       && TYPE_BEING_DEFINED (current_class_type)
8023       && (DECL_INITIAL (decl) || init))
8024     DECL_DEFINED_IN_CLASS_P (decl) = 1;
8025
8026   if (TREE_CODE (decl) == VAR_DECL
8027       && DECL_CONTEXT (decl)
8028       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
8029       && DECL_CONTEXT (decl) != current_namespace
8030       && init)
8031     {
8032       /* Leave the namespace of the object. */
8033       pop_decl_namespace ();
8034     }
8035
8036   type = TREE_TYPE (decl);
8037
8038   if (type == error_mark_node)
8039     return;
8040
8041   /* Add this declaration to the statement-tree.  */
8042   if (building_stmt_tree () && at_function_scope_p ())
8043     add_decl_stmt (decl);
8044
8045   if (TYPE_HAS_MUTABLE_P (type))
8046     TREE_READONLY (decl) = 0;
8047
8048   if (processing_template_decl)
8049     {
8050       if (init && DECL_INITIAL (decl))
8051         DECL_INITIAL (decl) = init;
8052       goto finish_end0;
8053     }
8054
8055   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
8056   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
8057
8058   /* Take care of TYPE_DECLs up front.  */
8059   if (TREE_CODE (decl) == TYPE_DECL)
8060     {
8061       if (init && DECL_INITIAL (decl))
8062         {
8063           /* typedef foo = bar; store the type of bar as the type of foo.  */
8064           TREE_TYPE (decl) = type = TREE_TYPE (init);
8065           DECL_INITIAL (decl) = init = NULL_TREE;
8066         }
8067       if (type != error_mark_node
8068           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
8069         {
8070           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
8071             cp_warning ("shadowing previous type declaration of `%#D'", decl);
8072           set_identifier_type_value (DECL_NAME (decl), type);
8073           CLASSTYPE_GOT_SEMICOLON (type) = 1;
8074         }
8075       GNU_xref_decl (current_function_decl, decl);
8076
8077       /* If we have installed this as the canonical typedef for this
8078          type, and that type has not been defined yet, delay emitting
8079          the debug information for it, as we will emit it later.  */
8080       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
8081           && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
8082         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
8083
8084       rest_of_decl_compilation (decl, NULL_PTR,
8085                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
8086       goto finish_end;
8087     }
8088
8089   if (TREE_CODE (decl) != FUNCTION_DECL)
8090     ttype = target_type (type);
8091
8092   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
8093       && TYPE_NEEDS_CONSTRUCTING (type))
8094     {
8095       /* Currently, GNU C++ puts constants in text space, making them
8096          impossible to initialize.  In the future, one would hope for
8097          an operating system which understood the difference between
8098          initialization and the running of a program.  */
8099       was_readonly = 1;
8100       TREE_READONLY (decl) = 0;
8101     }
8102
8103   if (TREE_CODE (decl) == FIELD_DECL && asmspec)
8104     {
8105       /* This must override the asm specifier which was placed by
8106          grokclassfn.  Lay this out fresh.  */
8107       DECL_RTL (TREE_TYPE (decl)) = NULL_RTX;
8108       DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
8109       make_decl_rtl (decl, asmspec, 0);
8110     }
8111
8112   /* Deduce size of array from initialization, if not already known.  */
8113   maybe_deduce_size_from_array_init (decl, init);
8114   init = check_initializer (decl, init);
8115
8116   GNU_xref_decl (current_function_decl, decl);
8117
8118   if (TREE_CODE (decl) == VAR_DECL)
8119     layout_var_decl (decl);
8120
8121   /* Output the assembler code and/or RTL code for variables and functions,
8122      unless the type is an undefined structure or union.
8123      If not, it will get done when the type is completed.  */
8124   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
8125       || TREE_CODE (decl) == RESULT_DECL)
8126     {
8127       if (TREE_CODE (decl) == VAR_DECL)
8128         maybe_commonize_var (decl);
8129
8130       make_rtl_for_nonlocal_decl (decl, init, asmspec);
8131
8132       if (TREE_CODE (type) == FUNCTION_TYPE
8133           || TREE_CODE (type) == METHOD_TYPE)
8134         abstract_virtuals_error (decl,
8135                                  strip_array_types (TREE_TYPE (type)));
8136       else
8137         abstract_virtuals_error (decl, strip_array_types (type));
8138
8139       if (TREE_CODE (decl) == FUNCTION_DECL)
8140         ;
8141       else if (DECL_EXTERNAL (decl)
8142                && ! (DECL_LANG_SPECIFIC (decl)
8143                      && DECL_NOT_REALLY_EXTERN (decl)))
8144         {
8145           if (init)
8146             DECL_INITIAL (decl) = init;
8147         }
8148       else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
8149         {
8150           /* This is a local declaration.  */
8151           if (doing_semantic_analysis_p ())
8152             maybe_inject_for_scope_var (decl);
8153           /* Initialize the local variable.  But, if we're building a
8154              statement-tree, we'll do the initialization when we
8155              expand the tree.  */
8156           if (processing_template_decl)
8157             {
8158               if (init || DECL_INITIAL (decl) == error_mark_node)
8159                 DECL_INITIAL (decl) = init;
8160             }
8161           else
8162             {
8163               /* If we're not building RTL, then we need to do so
8164                  now.  */
8165               if (!building_stmt_tree ())
8166                 emit_local_var (decl);
8167               /* Initialize the variable.  */
8168               initialize_local_var (decl, init, flags);
8169               /* Clean up the variable.  */
8170               destroy_local_var (decl);
8171             }
8172         }
8173       else if (TREE_STATIC (decl) && type != error_mark_node)
8174         {
8175           /* Cleanups for static variables are handled by `finish_file'.  */
8176           if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
8177               || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8178             expand_static_init (decl, init);
8179         }
8180     finish_end0:
8181
8182       /* Undo call to `pushclass' that was done in `start_decl'
8183          due to initialization of qualified member variable.
8184          I.e., Foo::x = 10;  */
8185       {
8186         tree context = CP_DECL_CONTEXT (decl);
8187         if (context
8188             && TYPE_P (context)
8189             && (TREE_CODE (decl) == VAR_DECL
8190                 /* We also have a pushclass done that we need to undo here
8191                    if we're at top level and declare a method.  */
8192                 || TREE_CODE (decl) == FUNCTION_DECL)
8193             /* If size hasn't been set, we're still defining it,
8194                and therefore inside the class body; don't pop
8195                the binding level..  */
8196             && COMPLETE_TYPE_P (context)
8197             && context == current_class_type)
8198           pop_nested_class ();
8199       }
8200     }
8201
8202  finish_end:
8203
8204   if (was_readonly)
8205     TREE_READONLY (decl) = 1;
8206 }
8207
8208 /* This is here for a midend callback from c-common.c */
8209
8210 void
8211 finish_decl (decl, init, asmspec_tree)
8212      tree decl, init;
8213      tree asmspec_tree;
8214 {
8215   cp_finish_decl (decl, init, asmspec_tree, 0);
8216 }
8217
8218 /* Returns a declaration for a VAR_DECL as if:
8219
8220      extern "C" TYPE NAME;
8221
8222    had been seen.  Used to create compiler-generated global
8223    variables.  */
8224
8225 tree
8226 declare_global_var (name, type)
8227      tree name;
8228      tree type;
8229 {
8230   tree decl;
8231
8232   push_to_top_level ();
8233   decl = build_decl (VAR_DECL, name, type);
8234   TREE_PUBLIC (decl) = 1;
8235   DECL_EXTERNAL (decl) = 1;
8236   DECL_ARTIFICIAL (decl) = 1;
8237   pushdecl (decl);
8238   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
8239   pop_from_top_level ();
8240
8241   return decl;
8242 }
8243
8244 /* Returns a pointer to the `atexit' function.  Note that if
8245    FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
8246    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
8247
8248 static tree
8249 get_atexit_node ()
8250 {
8251   tree atexit_fndecl;
8252   tree arg_types;
8253   tree fn_type;
8254   tree fn_ptr_type;
8255   const char *name;
8256
8257   if (atexit_node)
8258     return atexit_node;
8259
8260   if (flag_use_cxa_atexit)
8261     {
8262       /* The declaration for `__cxa_atexit' is:
8263
8264            int __cxa_atexit (void (*)(void *), void *, void *)
8265
8266          We build up the argument types and then then function type
8267          itself.  */
8268
8269       /* First, build the pointer-to-function type for the first
8270          argument.  */
8271       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8272       fn_type = build_function_type (void_type_node, arg_types);
8273       fn_ptr_type = build_pointer_type (fn_type);
8274       /* Then, build the rest of the argument types.  */
8275       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8276       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
8277       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
8278       /* And the final __cxa_atexit type.  */
8279       fn_type = build_function_type (integer_type_node, arg_types);
8280       fn_ptr_type = build_pointer_type (fn_type);
8281       name = "__cxa_atexit";
8282     }
8283   else
8284     {
8285       /* The declaration for `atexit' is:
8286
8287            int atexit (void (*)());
8288
8289          We build up the argument types and then then function type
8290          itself.  */
8291       fn_type = build_function_type (void_type_node, void_list_node);
8292       fn_ptr_type = build_pointer_type (fn_type);
8293       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
8294       /* Build the final atexit type.  */
8295       fn_type = build_function_type (integer_type_node, arg_types);
8296       name = "atexit";
8297     }
8298
8299   /* Now, build the function declaration.  */
8300   push_lang_context (lang_name_c);
8301   atexit_fndecl = build_library_fn_ptr (name, fn_type);
8302   mark_used (atexit_fndecl);
8303   pop_lang_context ();
8304   atexit_node = default_conversion (atexit_fndecl);
8305
8306   return atexit_node;
8307 }
8308
8309 /* Returns the __dso_handle VAR_DECL.  */
8310
8311 static tree
8312 get_dso_handle_node ()
8313 {
8314   if (dso_handle_node)
8315     return dso_handle_node;
8316
8317   /* Declare the variable.  */
8318   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8319                                         ptr_type_node);
8320
8321   return dso_handle_node;
8322 }
8323
8324 /* Begin a new function with internal linkage whose job will be simply
8325    to destroy some particular variable.  */
8326
8327 static tree
8328 start_cleanup_fn ()
8329 {
8330   static int counter = 0;
8331   int old_interface_unknown = interface_unknown;
8332   char name[32];
8333   tree parmtypes;
8334   tree fntype;
8335   tree fndecl;
8336
8337   push_to_top_level ();
8338
8339   /* No need to mangle this.  */
8340   push_lang_context (lang_name_c);
8341
8342   interface_unknown = 1;
8343
8344   /* Build the parameter-types.  */
8345   parmtypes = void_list_node;
8346   /* Functions passed to __cxa_atexit take an additional parameter.
8347      We'll just ignore it.  After we implement the new calling
8348      convention for destructors, we can eliminate the use of
8349      additional cleanup functions entirely in the -fnew-abi case.  */
8350   if (flag_use_cxa_atexit)
8351     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8352   /* Build the function type itself.  */
8353   fntype = build_function_type (void_type_node, parmtypes);
8354   /* Build the name of the function.  */
8355   sprintf (name, "__tcf_%d", counter++);
8356   /* Build the function declaration.  */
8357   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8358   /* It's a function with internal linkage, generated by the
8359      compiler.  */
8360   TREE_PUBLIC (fndecl) = 0;
8361   DECL_ARTIFICIAL (fndecl) = 1;
8362   /* Build the parameter.  */
8363   if (flag_use_cxa_atexit)
8364     {
8365       tree parmdecl;
8366
8367       parmdecl = build_decl (PARM_DECL, NULL_TREE, ptr_type_node);
8368       DECL_CONTEXT (parmdecl) = fndecl;
8369       DECL_ARG_TYPE (parmdecl) = ptr_type_node;
8370       TREE_USED (parmdecl) = 1;
8371       DECL_ARGUMENTS (fndecl) = parmdecl;
8372     }
8373
8374   pushdecl (fndecl);
8375   start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8376   do_pushlevel ();
8377
8378   interface_unknown = old_interface_unknown;
8379
8380   pop_lang_context ();
8381
8382   return current_function_decl;
8383 }
8384
8385 /* Finish the cleanup function begun by start_cleanup_fn.  */
8386
8387 static void
8388 end_cleanup_fn ()
8389 {
8390   do_poplevel ();
8391
8392   expand_body (finish_function (0));
8393
8394   pop_from_top_level ();
8395 }
8396
8397 /* Generate code to handle the destruction of DECL, an object with
8398    static storage duration.  */
8399
8400 void
8401 register_dtor_fn (decl)
8402      tree decl;
8403 {
8404   tree cleanup;
8405   tree compound_stmt;
8406   tree args;
8407   tree fcall;
8408
8409   int saved_flag_access_control;
8410
8411   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8412     return;
8413
8414   /* Call build_cleanup before we enter the anonymous function so that
8415      any access checks will be done relative to the current scope,
8416      rather than the scope of the anonymous function.  */
8417   build_cleanup (decl);
8418
8419   /* Now start the function.  */
8420   cleanup = start_cleanup_fn ();
8421
8422   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
8423      to the original function, rather than the anonymous one.  That
8424      will make the back-end think that nested functions are in use,
8425      which causes confusion.  */
8426   saved_flag_access_control = flag_access_control;
8427   flag_access_control = 0;
8428   fcall = build_cleanup (decl);
8429   flag_access_control = saved_flag_access_control;
8430
8431   /* Create the body of the anonymous function.  */
8432   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8433   finish_expr_stmt (fcall);
8434   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8435   end_cleanup_fn ();
8436
8437   /* Call atexit with the cleanup function.  */
8438   mark_addressable (cleanup);
8439   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8440   if (flag_use_cxa_atexit)
8441     {
8442       args = tree_cons (NULL_TREE, get_dso_handle_node (), NULL_TREE);
8443       args = tree_cons (NULL_TREE, null_pointer_node, args);
8444       args = tree_cons (NULL_TREE, cleanup, args);
8445     }
8446   else
8447     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8448   finish_expr_stmt (build_function_call (get_atexit_node (), args));
8449 }
8450
8451 void
8452 expand_static_init (decl, init)
8453      tree decl;
8454      tree init;
8455 {
8456   tree oldstatic = value_member (decl, static_aggregates);
8457
8458   if (oldstatic)
8459     {
8460       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8461         cp_error ("multiple initializations given for `%D'", decl);
8462     }
8463   else if (! toplevel_bindings_p ())
8464     {
8465       /* Emit code to perform this initialization but once.  */
8466       tree if_stmt;
8467       tree then_clause;
8468       tree assignment;
8469       tree guard;
8470       tree guard_init;
8471
8472       /* Emit code to perform this initialization but once.  This code
8473          looks like:
8474
8475            static int guard = 0;
8476            if (!guard) {
8477              // Do initialization.
8478              guard = 1;
8479              // Register variable for destruction at end of program.
8480            }
8481
8482          Note that the `temp' variable is only set to 1 *after* the
8483          initialization is complete.  This ensures that an exception,
8484          thrown during the construction, will cause the variable to
8485          reinitialized when we pass through this code again, as per:
8486
8487            [stmt.dcl]
8488
8489            If the initialization exits by throwing an exception, the
8490            initialization is not complete, so it will be tried again
8491            the next time control enters the declaration.
8492
8493          In theory, this process should be thread-safe, too; multiple
8494          threads should not be able to initialize the variable more
8495          than once.  We don't yet attempt to ensure thread-safety.  */
8496
8497       /* Create the guard variable.  */
8498       guard = get_guard (decl);
8499
8500       /* Begin the conditional initialization.  */
8501       if_stmt = begin_if_stmt ();
8502       finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
8503       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8504
8505       /* Do the initialization itself.  */
8506       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8507           || (init && TREE_CODE (init) == TREE_LIST))
8508         assignment = build_aggr_init (decl, init, 0);
8509       else if (init)
8510         /* The initialization we're doing here is just a bitwise
8511            copy.  */
8512         assignment = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
8513       else
8514         assignment = NULL_TREE;
8515
8516       /* Once the assignment is complete, set TEMP to 1.  Since the
8517          construction of the static object is complete at this point,
8518          we want to make sure TEMP is set to 1 even if a temporary
8519          constructed during the initialization throws an exception
8520          when it is destroyed.  So, we combine the initialization and
8521          the assignment to TEMP into a single expression, ensuring
8522          that when we call finish_expr_stmt the cleanups will not be
8523          run until after TEMP is set to 1.  */
8524       guard_init = set_guard (guard);
8525       if (assignment)
8526         {
8527           assignment = tree_cons (NULL_TREE, assignment,
8528                                   build_tree_list (NULL_TREE,
8529                                                    guard_init));
8530           assignment = build_compound_expr (assignment);
8531         }
8532       else
8533         assignment = guard_init;
8534       finish_expr_stmt (assignment);
8535
8536       /* Use atexit to register a function for destroying this static
8537          variable.  */
8538       register_dtor_fn (decl);
8539
8540       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8541       finish_then_clause (if_stmt);
8542       finish_if_stmt ();
8543     }
8544   else
8545     static_aggregates = tree_cons (init, decl, static_aggregates);
8546 }
8547
8548 /* Finish the declaration of a catch-parameter.  */
8549
8550 tree
8551 start_handler_parms (declspecs, declarator)
8552      tree declspecs;
8553      tree declarator;
8554 {
8555   tree decl;
8556   if (declspecs)
8557     {
8558       decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8559                              1, NULL_TREE);
8560       if (decl == NULL_TREE)
8561         error ("invalid catch parameter");
8562     }
8563   else
8564     decl = NULL_TREE;
8565
8566   return decl;
8567 }
8568
8569 \f
8570 /* Make TYPE a complete type based on INITIAL_VALUE.
8571    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8572    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
8573
8574 int
8575 complete_array_type (type, initial_value, do_default)
8576      tree type, initial_value;
8577      int do_default;
8578 {
8579   register tree maxindex = NULL_TREE;
8580   int value = 0;
8581
8582   if (initial_value)
8583     {
8584       /* An array of character type can be initialized from a
8585          brace-enclosed string constant.  */
8586       if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))
8587           && TREE_CODE (initial_value) == CONSTRUCTOR
8588           && CONSTRUCTOR_ELTS (initial_value)
8589           && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value)))
8590               == STRING_CST)
8591           && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value)) == NULL_TREE)
8592         initial_value = TREE_VALUE (CONSTRUCTOR_ELTS (initial_value));
8593
8594       /* Note MAXINDEX is really the maximum index, one less than the
8595          size.  */
8596       if (TREE_CODE (initial_value) == STRING_CST)
8597         {
8598           int eltsize
8599             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8600           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8601                                    / eltsize) - 1, 0);
8602         }
8603       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8604         {
8605           tree elts = CONSTRUCTOR_ELTS (initial_value);
8606
8607           maxindex = ssize_int (-1);
8608           for (; elts; elts = TREE_CHAIN (elts))
8609             {
8610               if (TREE_PURPOSE (elts))
8611                 maxindex = TREE_PURPOSE (elts);
8612               else
8613                 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
8614             }
8615           maxindex = copy_node (maxindex);
8616         }
8617       else
8618         {
8619           /* Make an error message unless that happened already.  */
8620           if (initial_value != error_mark_node)
8621             value = 1;
8622           else
8623             initial_value = NULL_TREE;
8624
8625           /* Prevent further error messages.  */
8626           maxindex = build_int_2 (0, 0);
8627         }
8628     }
8629
8630   if (!maxindex)
8631     {
8632       if (do_default)
8633         maxindex = build_int_2 (0, 0);
8634       value = 2;
8635     }
8636
8637   if (maxindex)
8638     {
8639       tree itype;
8640       tree domain;
8641
8642       domain = build_index_type (maxindex);
8643       TYPE_DOMAIN (type) = domain;
8644
8645       if (! TREE_TYPE (maxindex))
8646         TREE_TYPE (maxindex) = domain;
8647       if (initial_value)
8648         itype = TREE_TYPE (initial_value);
8649       else
8650         itype = NULL;
8651       if (itype && !TYPE_DOMAIN (itype))
8652         TYPE_DOMAIN (itype) = domain;
8653       /* The type of the main variant should never be used for arrays
8654          of different sizes.  It should only ever be completed with the
8655          size of the array.  */
8656       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8657         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8658     }
8659
8660   /* Lay out the type now that we can get the real answer.  */
8661
8662   layout_type (type);
8663
8664   return value;
8665 }
8666 \f
8667 /* Return zero if something is declared to be a member of type
8668    CTYPE when in the context of CUR_TYPE.  STRING is the error
8669    message to print in that case.  Otherwise, quietly return 1.  */
8670
8671 static int
8672 member_function_or_else (ctype, cur_type, flags)
8673      tree ctype, cur_type;
8674      enum overload_flags flags;
8675 {
8676   if (ctype && ctype != cur_type)
8677     {
8678       if (flags == DTOR_FLAG)
8679         error ("destructor for alien class `%s' cannot be a member",
8680                TYPE_NAME_STRING (ctype));
8681       else
8682         error ("constructor for alien class `%s' cannot be a member",
8683                TYPE_NAME_STRING (ctype));
8684       return 0;
8685     }
8686   return 1;
8687 }
8688 \f
8689 /* Subroutine of `grokdeclarator'.  */
8690
8691 /* Generate errors possibly applicable for a given set of specifiers.
8692    This is for ARM $7.1.2.  */
8693
8694 static void
8695 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8696      tree object;
8697      const char *type;
8698      int virtualp, quals, friendp, raises, inlinep;
8699 {
8700   if (virtualp)
8701     cp_error ("`%D' declared as a `virtual' %s", object, type);
8702   if (inlinep)
8703     cp_error ("`%D' declared as an `inline' %s", object, type);
8704   if (quals)
8705     cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8706               object, type);
8707   if (friendp)
8708     cp_error_at ("`%D' declared as a friend", object);
8709   if (raises)
8710     cp_error_at ("`%D' declared with an exception specification", object);
8711 }
8712
8713 /* CTYPE is class type, or null if non-class.
8714    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8715    or METHOD_TYPE.
8716    DECLARATOR is the function's name.
8717    VIRTUALP is truthvalue of whether the function is virtual or not.
8718    FLAGS are to be passed through to `grokclassfn'.
8719    QUALS are qualifiers indicating whether the function is `const'
8720    or `volatile'.
8721    RAISES is a list of exceptions that this function can raise.
8722    CHECK is 1 if we must find this method in CTYPE, 0 if we should
8723    not look, and -1 if we should not call `grokclassfn' at all.
8724
8725    Returns `NULL_TREE' if something goes wrong, after issuing
8726    applicable error messages.  */
8727
8728 static tree
8729 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8730             raises, check, friendp, publicp, inlinep, funcdef_flag,
8731             template_count, in_namespace)
8732      tree ctype, type;
8733      tree declarator;
8734      tree orig_declarator;
8735      int virtualp;
8736      enum overload_flags flags;
8737      tree quals, raises;
8738      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8739      tree in_namespace;
8740 {
8741   tree cname, decl;
8742   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8743   int has_default_arg = 0;
8744   tree t;
8745
8746   if (ctype)
8747     cname = TREE_CODE (TYPE_NAME (ctype)) == TYPE_DECL
8748       ? TYPE_IDENTIFIER (ctype) : TYPE_NAME (ctype);
8749   else
8750     cname = NULL_TREE;
8751
8752   if (raises)
8753     {
8754       type = build_exception_variant (type, raises);
8755     }
8756
8757   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8758   /* Propagate volatile out from type to decl. */
8759   if (TYPE_VOLATILE (type))
8760     TREE_THIS_VOLATILE (decl) = 1;
8761
8762   /* If this decl has namespace scope, set that up.  */
8763   if (in_namespace)
8764     set_decl_namespace (decl, in_namespace, friendp);
8765   else if (!ctype)
8766     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8767
8768   /* `main' and builtins have implicit 'C' linkage.  */
8769   if ((MAIN_NAME_P (declarator)
8770        || (IDENTIFIER_LENGTH (declarator) > 10
8771            && IDENTIFIER_POINTER (declarator)[0] == '_'
8772            && IDENTIFIER_POINTER (declarator)[1] == '_'
8773            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8774       && current_lang_name == lang_name_cplusplus
8775       && ctype == NULL_TREE
8776       /* NULL_TREE means global namespace.  */
8777       && DECL_CONTEXT (decl) == NULL_TREE)
8778     DECL_LANGUAGE (decl) = lang_c;
8779
8780   /* Should probably propagate const out from type to decl I bet (mrs).  */
8781   if (staticp)
8782     {
8783       DECL_STATIC_FUNCTION_P (decl) = 1;
8784       DECL_CONTEXT (decl) = ctype;
8785     }
8786
8787   if (ctype)
8788     DECL_CONTEXT (decl) = ctype;
8789
8790   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8791     {
8792       if (processing_template_decl)
8793         error ("cannot declare `::main' to be a template");
8794       if (inlinep)
8795         error ("cannot declare `::main' to be inline");
8796       else if (! publicp)
8797         error ("cannot declare `::main' to be static");
8798       inlinep = 0;
8799       publicp = 1;
8800     }
8801
8802   /* Members of anonymous types and local classes have no linkage; make
8803      them internal.  */
8804   if (ctype && (ANON_AGGRNAME_P (TYPE_IDENTIFIER (ctype))
8805                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
8806     publicp = 0;
8807
8808   if (publicp)
8809     {
8810       /* [basic.link]: A name with no linkage (notably, the name of a class
8811          or enumeration declared in a local scope) shall not be used to
8812          declare an entity with linkage.
8813
8814          Only check this for public decls for now.  */
8815       t = no_linkage_check (TREE_TYPE (decl));
8816       if (t)
8817         {
8818           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8819             {
8820               if (DECL_EXTERN_C_P (decl))
8821                 /* Allow this; it's pretty common in C.  */;
8822               else
8823                 cp_pedwarn ("non-local function `%#D' uses anonymous type",
8824                             decl);
8825             }
8826           else
8827             cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8828                         decl, t);
8829         }
8830     }
8831
8832   TREE_PUBLIC (decl) = publicp;
8833   if (! publicp)
8834     {
8835       DECL_INTERFACE_KNOWN (decl) = 1;
8836       DECL_NOT_REALLY_EXTERN (decl) = 1;
8837     }
8838
8839   if (inlinep)
8840     DECL_THIS_INLINE (decl) = DECL_INLINE (decl) = 1;
8841
8842   DECL_EXTERNAL (decl) = 1;
8843   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
8844     {
8845       cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8846                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
8847       quals = NULL_TREE;
8848     }
8849
8850   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
8851     grok_op_properties (decl, virtualp, check < 0);
8852
8853   if (ctype && decl_function_context (decl))
8854     DECL_NO_STATIC_CHAIN (decl) = 1;
8855
8856   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
8857     if (TREE_PURPOSE (t)
8858         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
8859       {
8860         has_default_arg = 1;
8861         break;
8862       }
8863
8864   if (friendp
8865       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
8866     {
8867       if (funcdef_flag)
8868         cp_error
8869           ("defining explicit specialization `%D' in friend declaration",
8870            orig_declarator);
8871       else
8872         {
8873           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8874             {
8875               /* Something like `template <class T> friend void f<T>()'.  */
8876               cp_error ("invalid use of template-id `%D' in declaration of primary template",
8877                         orig_declarator);
8878               return NULL_TREE;
8879             }
8880
8881
8882           /* A friend declaration of the form friend void f<>().  Record
8883              the information in the TEMPLATE_ID_EXPR.  */
8884           SET_DECL_IMPLICIT_INSTANTIATION (decl);
8885           DECL_TEMPLATE_INFO (decl)
8886             = tree_cons (TREE_OPERAND (orig_declarator, 0),
8887                          TREE_OPERAND (orig_declarator, 1),
8888                          NULL_TREE);
8889
8890           if (has_default_arg)
8891             {
8892               cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8893                         decl);
8894               return NULL_TREE;
8895             }
8896
8897           if (inlinep)
8898             {
8899               cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
8900                         decl);
8901               return NULL_TREE;
8902             }
8903         }
8904     }
8905
8906   if (has_default_arg)
8907     add_defarg_fn (decl);
8908
8909   /* Plain overloading: will not be grok'd by grokclassfn.  */
8910   if (! ctype && ! processing_template_decl
8911       && !DECL_EXTERN_C_P (decl)
8912       && (! DECL_USE_TEMPLATE (decl) || name_mangling_version < 1))
8913     set_mangled_name_for_decl (decl);
8914
8915   if (funcdef_flag)
8916     /* Make the init_value nonzero so pushdecl knows this is not
8917        tentative.  error_mark_node is replaced later with the BLOCK.  */
8918     DECL_INITIAL (decl) = error_mark_node;
8919
8920   if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
8921     TREE_NOTHROW (decl) = 1;
8922
8923   /* Caller will do the rest of this.  */
8924   if (check < 0)
8925     return decl;
8926
8927   if (flags == NO_SPECIAL && ctype && constructor_name (cname) == declarator)
8928     DECL_CONSTRUCTOR_P (decl) = 1;
8929
8930   /* Function gets the ugly name, field gets the nice one.  This call
8931      may change the type of the function (because of default
8932      parameters)!  */
8933   if (ctype != NULL_TREE)
8934     grokclassfn (ctype, decl, flags, quals);
8935
8936   decl = check_explicit_specialization (orig_declarator, decl,
8937                                         template_count,
8938                                         2 * (funcdef_flag != 0) +
8939                                         4 * (friendp != 0));
8940   if (decl == error_mark_node)
8941     return NULL_TREE;
8942
8943   if (ctype != NULL_TREE
8944       && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
8945       && check)
8946     {
8947       tree old_decl;
8948
8949       old_decl = check_classfn (ctype, decl);
8950
8951       if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
8952         /* Because grokfndecl is always supposed to return a
8953            FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
8954            here.  We depend on our callers to figure out that its
8955            really a template that's being returned.  */
8956         old_decl = DECL_TEMPLATE_RESULT (old_decl);
8957
8958       if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
8959           && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
8960         {
8961           /* Remove the `this' parm added by grokclassfn.
8962              XXX Isn't this done in start_function, too?  */
8963           revert_static_member_fn (decl);
8964           last_function_parms = TREE_CHAIN (last_function_parms);
8965         }
8966       if (old_decl && DECL_ARTIFICIAL (old_decl))
8967         cp_error ("definition of implicitly-declared `%D'", old_decl);
8968
8969       if (old_decl)
8970         {
8971           /* Since we've smashed OLD_DECL to its
8972              DECL_TEMPLATE_RESULT, we must do the same to DECL.  */
8973           if (TREE_CODE (decl) == TEMPLATE_DECL)
8974             decl = DECL_TEMPLATE_RESULT (decl);
8975
8976           /* Attempt to merge the declarations.  This can fail, in
8977              the case of some illegal specialization declarations.  */
8978           if (!duplicate_decls (decl, old_decl))
8979             cp_error ("no `%#D' member function declared in class `%T'",
8980                       decl, ctype);
8981           return old_decl;
8982         }
8983     }
8984
8985   if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
8986     return NULL_TREE;
8987
8988   if (ctype == NULL_TREE || check)
8989     return decl;
8990
8991   if (virtualp)
8992     {
8993       DECL_VIRTUAL_P (decl) = 1;
8994       if (DECL_VINDEX (decl) == NULL_TREE)
8995         DECL_VINDEX (decl) = error_mark_node;
8996       IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
8997     }
8998
8999   return decl;
9000 }
9001
9002 static tree
9003 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
9004      tree type;
9005      tree declarator;
9006      RID_BIT_TYPE *specbits_in;
9007      int initialized;
9008      int constp;
9009      tree in_namespace;
9010 {
9011   tree decl;
9012   RID_BIT_TYPE specbits;
9013
9014   specbits = *specbits_in;
9015
9016   if (TREE_CODE (type) == OFFSET_TYPE)
9017     {
9018       /* If you declare a static member so that it
9019          can be initialized, the code will reach here.  */
9020       tree basetype = TYPE_OFFSET_BASETYPE (type);
9021       type = TREE_TYPE (type);
9022       decl = build_lang_decl (VAR_DECL, declarator, type);
9023       DECL_CONTEXT (decl) = basetype;
9024       /* DECL_ASSEMBLER_NAME is needed only for full-instantiated
9025          templates.  */
9026       if (!uses_template_parms (decl))
9027         {
9028           if (flag_new_abi)
9029             DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
9030           else
9031             DECL_ASSEMBLER_NAME (decl) = build_static_name (basetype,
9032                                                             declarator);
9033         }
9034     }
9035   else
9036     {
9037       tree context;
9038
9039       if (in_namespace)
9040         context = in_namespace;
9041       else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
9042         context = current_namespace;
9043       else
9044         context = NULL_TREE;
9045
9046       if (processing_template_decl && context)
9047         /* For global variables, declared in a template, we need the
9048            full lang_decl.  */
9049         decl = build_lang_decl (VAR_DECL, declarator, type);
9050       else
9051         decl = build_decl (VAR_DECL, declarator, type);
9052
9053       if (context)
9054         set_decl_namespace (decl, context, 0);
9055
9056       context = DECL_CONTEXT (decl);
9057       if (declarator && context && current_lang_name != lang_name_c)
9058         {
9059           if (flag_new_abi)
9060             DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
9061           else
9062             DECL_ASSEMBLER_NAME (decl)
9063               = build_static_name (context, declarator);
9064         }
9065     }
9066
9067   if (in_namespace)
9068     set_decl_namespace (decl, in_namespace, 0);
9069
9070   if (RIDBIT_SETP (RID_EXTERN, specbits))
9071     {
9072       DECL_THIS_EXTERN (decl) = 1;
9073       DECL_EXTERNAL (decl) = !initialized;
9074     }
9075
9076   /* In class context, static means one per class,
9077      public access, and static storage.  */
9078   if (DECL_CLASS_SCOPE_P (decl))
9079     {
9080       TREE_PUBLIC (decl) = 1;
9081       TREE_STATIC (decl) = 1;
9082       DECL_EXTERNAL (decl) = 0;
9083     }
9084   /* At top level, either `static' or no s.c. makes a definition
9085      (perhaps tentative), and absence of `static' makes it public.  */
9086   else if (toplevel_bindings_p ())
9087     {
9088       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
9089                             && (DECL_THIS_EXTERN (decl) || ! constp));
9090       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
9091     }
9092   /* Not at top level, only `static' makes a static definition.  */
9093   else
9094     {
9095       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
9096       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
9097     }
9098
9099   if (TREE_PUBLIC (decl))
9100     {
9101       /* [basic.link]: A name with no linkage (notably, the name of a class
9102          or enumeration declared in a local scope) shall not be used to
9103          declare an entity with linkage.
9104
9105          Only check this for public decls for now.  */
9106       tree t = no_linkage_check (TREE_TYPE (decl));
9107       if (t)
9108         {
9109           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
9110             /* Ignore for now; `enum { foo } e' is pretty common.  */;
9111           else
9112             cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
9113                         decl, t);
9114         }
9115     }
9116
9117   return decl;
9118 }
9119
9120 /* Create and return a canonical pointer to member function type, for
9121    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
9122
9123 tree
9124 build_ptrmemfunc_type (type)
9125      tree type;
9126 {
9127   tree fields[4];
9128   tree t;
9129   tree u;
9130   tree unqualified_variant = NULL_TREE;
9131
9132   /* If a canonical type already exists for this type, use it.  We use
9133      this method instead of type_hash_canon, because it only does a
9134      simple equality check on the list of field members.  */
9135
9136   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
9137     return t;
9138
9139   /* Make sure that we always have the unqualified pointer-to-member
9140      type first.  */
9141   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9142     unqualified_variant
9143       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
9144
9145   t = make_aggr_type (RECORD_TYPE);
9146   /* Let the front-end know this is a pointer to member function...  */
9147   TYPE_PTRMEMFUNC_FLAG (t) = 1;
9148   /* ... and not really an aggregate.  */
9149   SET_IS_AGGR_TYPE (t, 0);
9150
9151   if (!flag_new_abi)
9152     {
9153       u = make_aggr_type (UNION_TYPE);
9154       SET_IS_AGGR_TYPE (u, 0);
9155       fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9156       fields[1] = build_decl (FIELD_DECL, delta2_identifier,
9157                               delta_type_node);
9158       finish_builtin_type (u, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9159       TYPE_NAME (u) = NULL_TREE;
9160
9161       fields[0] = build_decl (FIELD_DECL, delta_identifier,
9162                               delta_type_node);
9163       fields[1] = build_decl (FIELD_DECL, index_identifier,
9164                               delta_type_node);
9165       fields[2] = build_decl (FIELD_DECL, pfn_or_delta2_identifier, u);
9166       finish_builtin_type (t, "__ptrmemfunc_type", fields, 2, ptr_type_node);
9167     }
9168   else
9169     {
9170       fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9171       fields[1] = build_decl (FIELD_DECL, delta_identifier,
9172                               delta_type_node);
9173       finish_builtin_type (t, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9174     }
9175
9176   /* Zap out the name so that the back-end will give us the debugging
9177      information for this anonymous RECORD_TYPE.  */
9178   TYPE_NAME (t) = NULL_TREE;
9179
9180   /* If this is not the unqualified form of this pointer-to-member
9181      type, set the TYPE_MAIN_VARIANT for this type to be the
9182      unqualified type.  Since they are actually RECORD_TYPEs that are
9183      not variants of each other, we must do this manually.  */
9184   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9185     {
9186       t = build_qualified_type (t, CP_TYPE_QUALS (type));
9187       TYPE_MAIN_VARIANT (t) = unqualified_variant;
9188       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
9189       TYPE_NEXT_VARIANT (unqualified_variant) = t;
9190     }
9191
9192   /* Cache this pointer-to-member type so that we can find it again
9193      later.  */
9194   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
9195
9196   /* Seems to be wanted.  */
9197   CLASSTYPE_GOT_SEMICOLON (t) = 1;
9198
9199   return t;
9200 }
9201
9202 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9203    Check to see that the definition is valid.  Issue appropriate error
9204    messages.  Return 1 if the definition is particularly bad, or 0
9205    otherwise.  */
9206
9207 int
9208 check_static_variable_definition (decl, type)
9209      tree decl;
9210      tree type;
9211 {
9212   /* Motion 10 at San Diego: If a static const integral data member is
9213      initialized with an integral constant expression, the initializer
9214      may appear either in the declaration (within the class), or in
9215      the definition, but not both.  If it appears in the class, the
9216      member is a member constant.  The file-scope definition is always
9217      required.  */
9218   if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
9219     {
9220       cp_error ("invalid in-class initialization of static data member of non-integral type `%T'",
9221                 type);
9222       /* If we just return the declaration, crashes will sometimes
9223          occur.  We therefore return void_type_node, as if this was a
9224          friend declaration, to cause callers to completely ignore
9225          this declaration.  */
9226       return 1;
9227     }
9228   else if (!CP_TYPE_CONST_P (type))
9229     cp_error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9230               decl);
9231   else if (pedantic && !INTEGRAL_TYPE_P (type))
9232     cp_pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
9233
9234   return 0;
9235 }
9236
9237 /* Given the SIZE (i.e., number of elements) in an array, compute an
9238    appropriate index type for the array.  If non-NULL, NAME is the
9239    name of the thing being declared.  */
9240
9241 tree
9242 compute_array_index_type (name, size)
9243      tree name;
9244      tree size;
9245 {
9246   tree itype;
9247
9248   /* The size might be the result of a cast. */
9249   STRIP_TYPE_NOPS (size);
9250
9251   /* It might be a const variable or enumeration constant.  */
9252   size = decl_constant_value (size);
9253
9254   /* If this involves a template parameter, it will be a constant at
9255      instantiation time, but we don't know what the value is yet.
9256      Even if no template parameters are involved, we may an expression
9257      that is not a constant; we don't even simplify `1 + 2' when
9258      processing a template.  */
9259   if (processing_template_decl)
9260     {
9261       /* Resolve a qualified reference to an enumerator or static
9262          const data member of ours.  */
9263       if (TREE_CODE (size) == SCOPE_REF
9264           && TREE_OPERAND (size, 0) == current_class_type)
9265         {
9266           tree t = lookup_field (current_class_type,
9267                                  TREE_OPERAND (size, 1), 0, 0);
9268           if (t)
9269             size = t;
9270         }
9271
9272       return build_index_type (build_min (MINUS_EXPR, sizetype,
9273                                           size, integer_one_node));
9274     }
9275
9276   /* The array bound must be an integer type.  */
9277   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9278       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
9279       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
9280     {
9281       if (name)
9282         cp_error ("size of array `%D' has non-integer type", name);
9283       else
9284         cp_error ("size of array has non-integer type");
9285       size = integer_one_node;
9286     }
9287
9288   /* Normally, the array-bound will be a constant.  */
9289   if (TREE_CODE (size) == INTEGER_CST)
9290     {
9291       /* Check to see if the array bound overflowed.  Make that an
9292          error, no matter how generous we're being.  */
9293       int old_flag_pedantic_errors = flag_pedantic_errors;
9294       int old_pedantic = pedantic;
9295       pedantic = flag_pedantic_errors = 1;
9296       constant_expression_warning (size);
9297       pedantic = old_pedantic;
9298       flag_pedantic_errors = old_flag_pedantic_errors;
9299
9300       /* An array must have a positive number of elements.  */
9301       if (INT_CST_LT (size, integer_zero_node))
9302         {
9303           if (name)
9304             cp_error ("size of array `%D' is negative", name);
9305           else
9306             cp_error ("size of array is negative");
9307           size = integer_one_node;
9308         }
9309       /* Except that an extension we allow zero-sized arrays.  We
9310          always allow them in system headers because glibc uses
9311          them.  */
9312       else if (integer_zerop (size) && pedantic && !in_system_header)
9313         {
9314           if (name)
9315             cp_pedwarn ("ISO C++ forbids zero-size array `%D'", name);
9316           else
9317             cp_pedwarn ("ISO C++ forbids zero-size array");
9318         }
9319     }
9320   else if (TREE_CONSTANT (size))
9321     {
9322       /* `(int) &fn' is not a valid array bound.  */
9323       if (name)
9324         cp_error ("size of array `%D' is not an integral constant-expression",
9325                   name);
9326       else
9327         cp_error ("size of array is not an integral constant-expression");
9328     }
9329
9330   /* Compute the index of the largest element in the array.  It is
9331      one less than the number of elements in the array.  */
9332   itype
9333     = fold (cp_build_binary_op (MINUS_EXPR,
9334                                 cp_convert (ssizetype, size),
9335                                 cp_convert (ssizetype,
9336                                             integer_one_node)));
9337
9338   /* Check for variable-sized arrays.  We allow such things as an
9339      extension, even though they are not allowed in ANSI/ISO C++.  */
9340   if (!TREE_CONSTANT (itype))
9341     {
9342       if (pedantic)
9343         {
9344           if (name)
9345             cp_pedwarn ("ISO C++ forbids variable-size array `%D'",
9346                         name);
9347           else
9348             cp_pedwarn ("ISO C++ forbids variable-size array");
9349         }
9350
9351       /* Create a variable-sized array index type.  */
9352       itype = variable_size (itype);
9353     }
9354   /* Make sure that there was no overflow when creating to a signed
9355      index type.  (For example, on a 32-bit machine, an array with
9356      size 2^32 - 1 is too big.)  */
9357   else if (TREE_OVERFLOW (itype))
9358     {
9359       error ("overflow in array dimension");
9360       TREE_OVERFLOW (itype) = 0;
9361     }
9362
9363   /* Create and return the appropriate index type.  */
9364   return build_index_type (itype);
9365 }
9366
9367 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9368    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
9369    with this type.  */
9370
9371 static tree
9372 create_array_type_for_decl (name, type, size)
9373      tree name;
9374      tree type;
9375      tree size;
9376 {
9377   tree itype = NULL_TREE;
9378   const char* error_msg;
9379
9380   /* If things have already gone awry, bail now.  */
9381   if (type == error_mark_node || size == error_mark_node)
9382     return error_mark_node;
9383
9384   /* Assume that everything will go OK.  */
9385   error_msg = NULL;
9386
9387   /* There are some types which cannot be array elements.  */
9388   switch (TREE_CODE (type))
9389     {
9390     case VOID_TYPE:
9391       error_msg = "array of void";
9392       break;
9393
9394     case FUNCTION_TYPE:
9395       error_msg = "array of functions";
9396       break;
9397
9398     case REFERENCE_TYPE:
9399       error_msg = "array of references";
9400       break;
9401
9402     case OFFSET_TYPE:
9403       error_msg = "array of data members";
9404       break;
9405
9406     case METHOD_TYPE:
9407       error_msg = "array of function members";
9408       break;
9409
9410     default:
9411       break;
9412     }
9413
9414   /* If something went wrong, issue an error-message and return.  */
9415   if (error_msg)
9416     {
9417       if (name)
9418         cp_error ("declaration of `%D' as %s", name, error_msg);
9419       else
9420         cp_error ("creating %s", error_msg);
9421
9422       return error_mark_node;
9423     }
9424
9425   /* [dcl.array]
9426
9427      The constant expressions that specify the bounds of the arrays
9428      can be omitted only for the first member of the sequence.  */
9429   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9430     {
9431       cp_error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9432                 name);
9433
9434       return error_mark_node;
9435     }
9436
9437   /* Figure out the index type for the array.  */
9438   if (size)
9439     itype = compute_array_index_type (name, size);
9440
9441   return build_cplus_array_type (type, itype);
9442 }
9443
9444 /* Check that it's OK to declare a function with the indicated TYPE.
9445    SFK indicates the kind of special function (if any) that this
9446    function is.  CTYPE is the class of which this function is a
9447    member.  OPTYPE is the type given in a conversion operator
9448    declaration.  Returns the actual return type of the function; that
9449    may be different than TYPE if an error occurs, or for certain
9450    special functions.  */
9451
9452 static tree
9453 check_special_function_return_type (sfk, type, ctype, optype)
9454      special_function_kind sfk;
9455      tree type;
9456      tree ctype;
9457      tree optype;
9458 {
9459   switch (sfk)
9460     {
9461     case sfk_constructor:
9462       if (type)
9463         cp_error ("return type specification for constructor invalid");
9464
9465       /* In the old ABI, we return `this'; in the new ABI we don't
9466          bother.  */
9467       type = flag_new_abi ? void_type_node : build_pointer_type (ctype);
9468       break;
9469
9470     case sfk_destructor:
9471       if (type)
9472         cp_error ("return type specification for destructor invalid");
9473       type = void_type_node;
9474       break;
9475
9476     case sfk_conversion:
9477       if (type && !same_type_p (type, optype))
9478         cp_error ("operator `%T' declared to return `%T'", optype, type);
9479       else if (type)
9480         cp_pedwarn ("return type specified for `operator %T'",  optype);
9481       type = optype;
9482       break;
9483
9484     default:
9485       my_friendly_abort (20000408);
9486       break;
9487     }
9488
9489   return type;
9490 }
9491
9492 /* Given declspecs and a declarator,
9493    determine the name and type of the object declared
9494    and construct a ..._DECL node for it.
9495    (In one case we can return a ..._TYPE node instead.
9496     For invalid input we sometimes return 0.)
9497
9498    DECLSPECS is a chain of tree_list nodes whose value fields
9499     are the storage classes and type specifiers.
9500
9501    DECL_CONTEXT says which syntactic context this declaration is in:
9502      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9503      FUNCDEF for a function definition.  Like NORMAL but a few different
9504       error messages in each case.  Return value may be zero meaning
9505       this definition is too screwy to try to parse.
9506      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
9507       handle member functions (which have FIELD context).
9508       Return value may be zero meaning this definition is too screwy to
9509       try to parse.
9510      PARM for a parameter declaration (either within a function prototype
9511       or before a function body).  Make a PARM_DECL, or return void_type_node.
9512      CATCHPARM for a parameter declaration before a catch clause.
9513      TYPENAME if for a typename (in a cast or sizeof).
9514       Don't make a DECL node; just return the ..._TYPE node.
9515      FIELD for a struct or union field; make a FIELD_DECL.
9516      BITFIELD for a field with specified width.
9517    INITIALIZED is 1 if the decl has an initializer.
9518
9519    ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
9520    normal attributes in TREE_PURPOSE, or NULL_TREE.
9521
9522    In the TYPENAME case, DECLARATOR is really an abstract declarator.
9523    It may also be so in the PARM case, for a prototype where the
9524    argument type is specified but not the name.
9525
9526    This function is where the complicated C meanings of `static'
9527    and `extern' are interpreted.
9528
9529    For C++, if there is any monkey business to do, the function which
9530    calls this one must do it, i.e., prepending instance variables,
9531    renaming overloaded function names, etc.
9532
9533    Note that for this C++, it is an error to define a method within a class
9534    which does not belong to that class.
9535
9536    Except in the case where SCOPE_REFs are implicitly known (such as
9537    methods within a class being redundantly qualified),
9538    declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9539    (class_name::decl_name).  The caller must also deal with this.
9540
9541    If a constructor or destructor is seen, and the context is FIELD,
9542    then the type gains the attribute TREE_HAS_x.  If such a declaration
9543    is erroneous, NULL_TREE is returned.
9544
9545    QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
9546    function, these are the qualifiers to give to the `this' pointer. We
9547    apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9548
9549    May return void_type_node if the declarator turned out to be a friend.
9550    See grokfield for details.  */
9551
9552 tree
9553 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9554      tree declspecs;
9555      tree declarator;
9556      enum decl_context decl_context;
9557      int initialized;
9558      tree attrlist;
9559 {
9560   RID_BIT_TYPE specbits;
9561   int nclasses = 0;
9562   tree spec;
9563   tree type = NULL_TREE;
9564   int longlong = 0;
9565   int constp;
9566   int restrictp;
9567   int volatilep;
9568   int type_quals;
9569   int virtualp, explicitp, friendp, inlinep, staticp;
9570   int explicit_int = 0;
9571   int explicit_char = 0;
9572   int defaulted_int = 0;
9573   tree typedef_decl = NULL_TREE;
9574   const char *name;
9575   tree typedef_type = NULL_TREE;
9576   int funcdef_flag = 0;
9577   enum tree_code innermost_code = ERROR_MARK;
9578   int bitfield = 0;
9579 #if 0
9580   /* See the code below that used this.  */
9581   tree decl_machine_attr = NULL_TREE;
9582 #endif
9583   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9584      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9585   tree init = NULL_TREE;
9586
9587   /* Keep track of what sort of function is being processed
9588      so that we can warn about default return values, or explicit
9589      return values which do not match prescribed defaults.  */
9590   special_function_kind sfk = sfk_none;
9591
9592   tree dname = NULL_TREE;
9593   tree ctype = current_class_type;
9594   tree ctor_return_type = NULL_TREE;
9595   enum overload_flags flags = NO_SPECIAL;
9596   tree quals = NULL_TREE;
9597   tree raises = NULL_TREE;
9598   int template_count = 0;
9599   tree in_namespace = NULL_TREE;
9600   tree inner_attrs;
9601   int ignore_attrs;
9602
9603   RIDBIT_RESET_ALL (specbits);
9604   if (decl_context == FUNCDEF)
9605     funcdef_flag = 1, decl_context = NORMAL;
9606   else if (decl_context == MEMFUNCDEF)
9607     funcdef_flag = -1, decl_context = FIELD;
9608   else if (decl_context == BITFIELD)
9609     bitfield = 1, decl_context = FIELD;
9610
9611   /* Look inside a declarator for the name being declared
9612      and get it as a string, for an error message.  */
9613   {
9614     tree *next = &declarator;
9615     register tree decl;
9616     name = NULL;
9617
9618     while (next && *next)
9619       {
9620         decl = *next;
9621         switch (TREE_CODE (decl))
9622           {
9623           case TREE_LIST:
9624             /* For attributes.  */
9625             next = &TREE_VALUE (decl);
9626             break;
9627
9628           case COND_EXPR:
9629             ctype = NULL_TREE;
9630             next = &TREE_OPERAND (decl, 0);
9631             break;
9632
9633           case BIT_NOT_EXPR:    /* For C++ destructors!  */
9634             {
9635               tree name = TREE_OPERAND (decl, 0);
9636               tree rename = NULL_TREE;
9637
9638               my_friendly_assert (flags == NO_SPECIAL, 152);
9639               flags = DTOR_FLAG;
9640               sfk = sfk_destructor;
9641               if (TREE_CODE (name) == TYPE_DECL)
9642                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9643               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9644               if (ctype == NULL_TREE)
9645                 {
9646                   if (current_class_type == NULL_TREE)
9647                     {
9648                       error ("destructors must be member functions");
9649                       flags = NO_SPECIAL;
9650                     }
9651                   else
9652                     {
9653                       tree t = constructor_name (current_class_name);
9654                       if (t != name)
9655                         rename = t;
9656                     }
9657                 }
9658               else
9659                 {
9660                   tree t = constructor_name (ctype);
9661                   if (t != name)
9662                     rename = t;
9663                 }
9664
9665               if (rename)
9666                 {
9667                   cp_error ("destructor `%T' must match class name `%T'",
9668                             name, rename);
9669                   TREE_OPERAND (decl, 0) = rename;
9670                 }
9671               next = &name;
9672             }
9673             break;
9674
9675           case ADDR_EXPR:       /* C++ reference declaration */
9676             /* Fall through. */
9677           case ARRAY_REF:
9678           case INDIRECT_REF:
9679             ctype = NULL_TREE;
9680             innermost_code = TREE_CODE (decl);
9681             next = &TREE_OPERAND (decl, 0);
9682             break;
9683
9684           case CALL_EXPR:
9685             if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
9686               {
9687                 /* This is actually a variable declaration using
9688                    constructor syntax.  We need to call start_decl and
9689                    cp_finish_decl so we can get the variable
9690                    initialized...  */
9691
9692                 tree attributes, prefix_attributes;
9693
9694                 *next = TREE_OPERAND (decl, 0);
9695                 init = CALL_DECLARATOR_PARMS (decl);
9696
9697                 if (attrlist)
9698                   {
9699                     attributes = TREE_PURPOSE (attrlist);
9700                     prefix_attributes = TREE_VALUE (attrlist);
9701                   }
9702                 else
9703                   {
9704                     attributes = NULL_TREE;
9705                     prefix_attributes = NULL_TREE;
9706                   }
9707
9708                 decl = start_decl (declarator, declspecs, 1,
9709                                    attributes, prefix_attributes);
9710                 decl_type_access_control (decl);
9711                 if (decl)
9712                   {
9713                     /* Look for __unused__ attribute */
9714                     if (TREE_USED (TREE_TYPE (decl)))
9715                       TREE_USED (decl) = 1;
9716                     finish_decl (decl, init, NULL_TREE);
9717                   }
9718                 else
9719                   cp_error ("invalid declarator");
9720                 return 0;
9721               }
9722             innermost_code = TREE_CODE (decl);
9723             if (decl_context == FIELD && ctype == NULL_TREE)
9724               ctype = current_class_type;
9725             if (ctype
9726                 && TREE_OPERAND (decl, 0)
9727                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9728                     && ((DECL_NAME (TREE_OPERAND (decl, 0))
9729                          == constructor_name_full (ctype))
9730                         || (DECL_NAME (TREE_OPERAND (decl, 0))
9731                             == constructor_name (ctype)))))
9732               TREE_OPERAND (decl, 0) = constructor_name (ctype);
9733             next = &TREE_OPERAND (decl, 0);
9734             decl = *next;
9735             if (ctype != NULL_TREE
9736                 && decl != NULL_TREE && flags != DTOR_FLAG
9737                 && decl == constructor_name (ctype))
9738               {
9739                 sfk = sfk_constructor;
9740                 ctor_return_type = ctype;
9741               }
9742             ctype = NULL_TREE;
9743             break;
9744
9745           case TEMPLATE_ID_EXPR:
9746               {
9747                 tree fns = TREE_OPERAND (decl, 0);
9748
9749                 if (TREE_CODE (fns) == LOOKUP_EXPR)
9750                   fns = TREE_OPERAND (fns, 0);
9751
9752                 dname = fns;
9753                 if (TREE_CODE (dname) == COMPONENT_REF)
9754                   dname = TREE_OPERAND (dname, 1);
9755                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9756                   {
9757                     my_friendly_assert (is_overloaded_fn (dname),
9758                                         19990331);
9759                     dname = DECL_NAME (get_first_fn (dname));
9760                   }
9761               }
9762           /* Fall through. */
9763
9764           case IDENTIFIER_NODE:
9765             if (TREE_CODE (decl) == IDENTIFIER_NODE)
9766               dname = decl;
9767
9768             next = 0;
9769
9770             if (is_rid (dname))
9771               {
9772                 cp_error ("declarator-id missing; using reserved word `%D'",
9773                           dname);
9774                 name = IDENTIFIER_POINTER (dname);
9775               }
9776             else if (!IDENTIFIER_TYPENAME_P (dname))
9777               name = IDENTIFIER_POINTER (dname);
9778             else
9779               {
9780                 my_friendly_assert (flags == NO_SPECIAL, 154);
9781                 flags = TYPENAME_FLAG;
9782                 ctor_return_type = TREE_TYPE (dname);
9783                 sfk = sfk_conversion;
9784                 if (IDENTIFIER_GLOBAL_VALUE (dname)
9785                     && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (dname))
9786                         == TYPE_DECL))
9787                   name = IDENTIFIER_POINTER (dname);
9788                 else
9789                   name = "<invalid operator>";
9790               }
9791             break;
9792
9793             /* C++ extension */
9794           case SCOPE_REF:
9795             {
9796               /* Perform error checking, and decide on a ctype.  */
9797               tree cname = TREE_OPERAND (decl, 0);
9798               if (cname == NULL_TREE)
9799                 ctype = NULL_TREE;
9800               else if (TREE_CODE (cname) == NAMESPACE_DECL)
9801                 {
9802                   ctype = NULL_TREE;
9803                   in_namespace = TREE_OPERAND (decl, 0);
9804                   TREE_OPERAND (decl, 0) = NULL_TREE;
9805                 }
9806               else if (! is_aggr_type (cname, 1))
9807                 TREE_OPERAND (decl, 0) = NULL_TREE;
9808               /* Must test TREE_OPERAND (decl, 1), in case user gives
9809                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
9810               else if (TREE_OPERAND (decl, 1)
9811                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9812                 ctype = cname;
9813               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9814                        || TREE_CODE (cname) == TEMPLATE_TEMPLATE_PARM)
9815                 {
9816                   cp_error ("`%T::%D' is not a valid declarator", cname,
9817                             TREE_OPERAND (decl, 1));
9818                   cp_error ("  perhaps you want `typename %T::%D' to make it a type",
9819                             cname, TREE_OPERAND (decl, 1));
9820                   return void_type_node;
9821                 }
9822               else if (ctype == NULL_TREE)
9823                 ctype = cname;
9824               else if (TREE_COMPLEXITY (decl) == current_class_depth)
9825                 TREE_OPERAND (decl, 0) = ctype;
9826               else
9827                 {
9828                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9829                     {
9830                       cp_error ("type `%T' is not derived from type `%T'",
9831                                 cname, ctype);
9832                       TREE_OPERAND (decl, 0) = NULL_TREE;
9833                     }
9834                   else
9835                     ctype = cname;
9836                 }
9837
9838               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
9839                   && ((DECL_NAME (TREE_OPERAND (decl, 1))
9840                        == constructor_name_full (ctype))
9841                       || (DECL_NAME (TREE_OPERAND (decl, 1))
9842                           == constructor_name (ctype))))
9843                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
9844               next = &TREE_OPERAND (decl, 1);
9845               decl = *next;
9846               if (ctype)
9847                 {
9848                   if (TREE_CODE (decl) == IDENTIFIER_NODE
9849                       && constructor_name (ctype) == decl)
9850                     {
9851                       sfk = sfk_constructor;
9852                       ctor_return_type = ctype;
9853                     }
9854                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
9855                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
9856                            && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
9857                                || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
9858                     {
9859                       sfk = sfk_destructor;
9860                       ctor_return_type = ctype;
9861                       flags = DTOR_FLAG;
9862                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
9863                       next = &TREE_OPERAND (decl, 0);
9864                     }
9865                 }
9866             }
9867             break;
9868
9869           case ERROR_MARK:
9870             next = 0;
9871             break;
9872
9873           case TYPE_DECL:
9874             /* Parse error puts this typespec where
9875                a declarator should go.  */
9876             cp_error ("`%T' specified as declarator-id", DECL_NAME (decl));
9877             if (TREE_TYPE (decl) == current_class_type)
9878               cp_error ("  perhaps you want `%T' for a constructor",
9879                         current_class_name);
9880             dname = DECL_NAME (decl);
9881             name = IDENTIFIER_POINTER (dname);
9882
9883             /* Avoid giving two errors for this.  */
9884             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
9885
9886             declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
9887             *next = dname;
9888             next = 0;
9889             break;
9890
9891           default:
9892             cp_compiler_error ("`%D' as declarator", decl);
9893             return 0; /* We used to do a 155 abort here.  */
9894           }
9895       }
9896   }
9897
9898   /* A function definition's declarator must have the form of
9899      a function declarator.  */
9900
9901   if (funcdef_flag && innermost_code != CALL_EXPR)
9902     return 0;
9903
9904   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
9905       && innermost_code != CALL_EXPR
9906       && ! (ctype && declspecs == NULL_TREE))
9907     {
9908       cp_error ("declaration of `%D' as non-function", dname);
9909       return void_type_node;
9910     }
9911
9912   /* Anything declared one level down from the top level
9913      must be one of the parameters of a function
9914      (because the body is at least two levels down).  */
9915
9916   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9917      by not allowing C++ class definitions to specify their parameters
9918      with xdecls (must be spec.d in the parmlist).
9919
9920      Since we now wait to push a class scope until we are sure that
9921      we are in a legitimate method context, we must set oldcname
9922      explicitly (since current_class_name is not yet alive).
9923
9924      We also want to avoid calling this a PARM if it is in a namespace.  */
9925
9926   if (decl_context == NORMAL && !toplevel_bindings_p ())
9927     {
9928       struct binding_level *b = current_binding_level;
9929       current_binding_level = b->level_chain;
9930       if (current_binding_level != 0 && toplevel_bindings_p ())
9931         decl_context = PARM;
9932       current_binding_level = b;
9933     }
9934
9935   if (name == NULL)
9936     name = decl_context == PARM ? "parameter" : "type name";
9937
9938   /* Look through the decl specs and record which ones appear.
9939      Some typespecs are defined as built-in typenames.
9940      Others, the ones that are modifiers of other types,
9941      are represented by bits in SPECBITS: set the bits for
9942      the modifiers that appear.  Storage class keywords are also in SPECBITS.
9943
9944      If there is a typedef name or a type, store the type in TYPE.
9945      This includes builtin typedefs such as `int'.
9946
9947      Set EXPLICIT_INT if the type is `int' or `char' and did not
9948      come from a user typedef.
9949
9950      Set LONGLONG if `long' is mentioned twice.
9951
9952      For C++, constructors and destructors have their own fast treatment.  */
9953
9954   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
9955     {
9956       register int i;
9957       register tree id;
9958
9959       /* Certain parse errors slip through.  For example,
9960          `int class;' is not caught by the parser. Try
9961          weakly to recover here.  */
9962       if (TREE_CODE (spec) != TREE_LIST)
9963         return 0;
9964
9965       id = TREE_VALUE (spec);
9966
9967       if (TREE_CODE (id) == IDENTIFIER_NODE)
9968         {
9969           if (id == ridpointers[(int) RID_INT]
9970               || id == ridpointers[(int) RID_CHAR]
9971               || id == ridpointers[(int) RID_BOOL]
9972               || id == ridpointers[(int) RID_WCHAR])
9973             {
9974               if (type)
9975                 {
9976                   if (id == ridpointers[(int) RID_BOOL])
9977                     error ("`bool' is now a keyword");
9978                   else
9979                     cp_error ("extraneous `%T' ignored", id);
9980                 }
9981               else
9982                 {
9983                   if (id == ridpointers[(int) RID_INT])
9984                     explicit_int = 1;
9985                   else if (id == ridpointers[(int) RID_CHAR])
9986                     explicit_char = 1;
9987                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
9988                 }
9989               goto found;
9990             }
9991           /* C++ aggregate types.  */
9992           if (IDENTIFIER_HAS_TYPE_VALUE (id))
9993             {
9994               if (type)
9995                 cp_error ("multiple declarations `%T' and `%T'", type, id);
9996               else
9997                 type = IDENTIFIER_TYPE_VALUE (id);
9998               goto found;
9999             }
10000
10001           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
10002             {
10003               if (ridpointers[i] == id)
10004                 {
10005                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
10006                     {
10007                       if (pedantic && ! in_system_header && warn_long_long)
10008                         pedwarn ("ISO C++ does not support `long long'");
10009                       if (longlong)
10010                         error ("`long long long' is too long for GCC");
10011                       else
10012                         longlong = 1;
10013                     }
10014                   else if (RIDBIT_SETP (i, specbits))
10015                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
10016                   RIDBIT_SET (i, specbits);
10017                   goto found;
10018                 }
10019             }
10020         }
10021       /* C++ aggregate types.  */
10022       else if (TREE_CODE (id) == TYPE_DECL)
10023         {
10024           if (type)
10025             cp_error ("multiple declarations `%T' and `%T'", type,
10026                       TREE_TYPE (id));
10027           else
10028             {
10029               type = TREE_TYPE (id);
10030               TREE_VALUE (spec) = type;
10031             }
10032           goto found;
10033         }
10034       if (type)
10035         error ("two or more data types in declaration of `%s'", name);
10036       else if (TREE_CODE (id) == IDENTIFIER_NODE)
10037         {
10038           register tree t = lookup_name (id, 1);
10039           if (!t || TREE_CODE (t) != TYPE_DECL)
10040             error ("`%s' fails to be a typedef or built in type",
10041                    IDENTIFIER_POINTER (id));
10042           else
10043             {
10044               type = TREE_TYPE (t);
10045 #if 0
10046               /* See the code below that used this.  */
10047               decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
10048 #endif
10049               typedef_decl = t;
10050             }
10051         }
10052       else if (id != error_mark_node)
10053         /* Can't change CLASS nodes into RECORD nodes here!  */
10054         type = id;
10055
10056     found: ;
10057     }
10058
10059   typedef_type = type;
10060
10061   /* No type at all: default to `int', and set DEFAULTED_INT
10062      because it was not a user-defined typedef.  */
10063
10064   if (type == NULL_TREE
10065       && (RIDBIT_SETP (RID_SIGNED, specbits)
10066           || RIDBIT_SETP (RID_UNSIGNED, specbits)
10067           || RIDBIT_SETP (RID_LONG, specbits)
10068           || RIDBIT_SETP (RID_SHORT, specbits)))
10069     {
10070       /* These imply 'int'.  */
10071       type = integer_type_node;
10072       defaulted_int = 1;
10073     }
10074
10075   if (sfk != sfk_none)
10076     type = check_special_function_return_type (sfk, type,
10077                                                ctor_return_type,
10078                                                ctor_return_type);
10079   else if (type == NULL_TREE)
10080     {
10081       int is_main;
10082
10083       explicit_int = -1;
10084
10085           /* We handle `main' specially here, because 'main () { }' is so
10086              common.  With no options, it is allowed.  With -Wreturn-type,
10087              it is a warning.  It is only an error with -pedantic-errors.  */
10088       is_main = (funcdef_flag
10089                  && MAIN_NAME_P (dname)
10090                  && ctype == NULL_TREE
10091                  && in_namespace == NULL_TREE
10092                  && current_namespace == global_namespace);
10093
10094       if (in_system_header || flag_ms_extensions)
10095         /* Allow it, sigh.  */;
10096       else if (pedantic || ! is_main)
10097         cp_pedwarn ("ISO C++ forbids declaration of `%s' with no type",
10098                     name);
10099       else if (warn_return_type)
10100         cp_warning ("ISO C++ forbids declaration of `%s' with no type",
10101                     name);
10102
10103       type = integer_type_node;
10104     }
10105
10106   ctype = NULL_TREE;
10107
10108   /* Now process the modifiers that were specified
10109      and check for invalid combinations.  */
10110
10111   /* Long double is a special combination.  */
10112
10113   if (RIDBIT_SETP (RID_LONG, specbits)
10114       && TYPE_MAIN_VARIANT (type) == double_type_node)
10115     {
10116       RIDBIT_RESET (RID_LONG, specbits);
10117       type = build_qualified_type (long_double_type_node,
10118                                    CP_TYPE_QUALS (type));
10119     }
10120
10121   /* Check all other uses of type modifiers.  */
10122
10123   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10124       || RIDBIT_SETP (RID_SIGNED, specbits)
10125       || RIDBIT_SETP (RID_LONG, specbits)
10126       || RIDBIT_SETP (RID_SHORT, specbits))
10127     {
10128       int ok = 0;
10129
10130       if (TREE_CODE (type) == REAL_TYPE)
10131         error ("short, signed or unsigned invalid for `%s'", name);
10132       else if (TREE_CODE (type) != INTEGER_TYPE)
10133         error ("long, short, signed or unsigned invalid for `%s'", name);
10134       else if (RIDBIT_SETP (RID_LONG, specbits)
10135                && RIDBIT_SETP (RID_SHORT, specbits))
10136         error ("long and short specified together for `%s'", name);
10137       else if ((RIDBIT_SETP (RID_LONG, specbits)
10138                 || RIDBIT_SETP (RID_SHORT, specbits))
10139                && explicit_char)
10140         error ("long or short specified with char for `%s'", name);
10141       else if ((RIDBIT_SETP (RID_LONG, specbits)
10142                 || RIDBIT_SETP (RID_SHORT, specbits))
10143                && TREE_CODE (type) == REAL_TYPE)
10144         error ("long or short specified with floating type for `%s'", name);
10145       else if (RIDBIT_SETP (RID_SIGNED, specbits)
10146                && RIDBIT_SETP (RID_UNSIGNED, specbits))
10147         error ("signed and unsigned given together for `%s'", name);
10148       else
10149         {
10150           ok = 1;
10151           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
10152             {
10153               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10154                        name);
10155               if (flag_pedantic_errors)
10156                 ok = 0;
10157             }
10158         }
10159
10160       /* Discard the type modifiers if they are invalid.  */
10161       if (! ok)
10162         {
10163           RIDBIT_RESET (RID_UNSIGNED, specbits);
10164           RIDBIT_RESET (RID_SIGNED, specbits);
10165           RIDBIT_RESET (RID_LONG, specbits);
10166           RIDBIT_RESET (RID_SHORT, specbits);
10167           longlong = 0;
10168         }
10169     }
10170
10171   if (RIDBIT_SETP (RID_COMPLEX, specbits)
10172       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
10173     {
10174       error ("complex invalid for `%s'", name);
10175       RIDBIT_RESET (RID_COMPLEX, specbits);
10176     }
10177
10178   /* Decide whether an integer type is signed or not.
10179      Optionally treat bitfields as signed by default.  */
10180   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10181       /* [class.bit]
10182
10183          It is implementation-defined whether a plain (neither
10184          explicitly signed or unsigned) char, short, int, or long
10185          bit-field is signed or unsigned.
10186
10187          Naturally, we extend this to long long as well.  Note that
10188          this does not include wchar_t.  */
10189       || (bitfield && !flag_signed_bitfields
10190           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
10191           /* A typedef for plain `int' without `signed' can be
10192              controlled just like plain `int', but a typedef for
10193              `signed int' cannot be so controlled.  */
10194           && !(typedef_decl
10195                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
10196           && (TREE_CODE (type) == INTEGER_TYPE
10197               || TREE_CODE (type) == CHAR_TYPE)
10198           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
10199     {
10200       if (longlong)
10201         type = long_long_unsigned_type_node;
10202       else if (RIDBIT_SETP (RID_LONG, specbits))
10203         type = long_unsigned_type_node;
10204       else if (RIDBIT_SETP (RID_SHORT, specbits))
10205         type = short_unsigned_type_node;
10206       else if (type == char_type_node)
10207         type = unsigned_char_type_node;
10208       else if (typedef_decl)
10209         type = unsigned_type (type);
10210       else
10211         type = unsigned_type_node;
10212     }
10213   else if (RIDBIT_SETP (RID_SIGNED, specbits)
10214            && type == char_type_node)
10215     type = signed_char_type_node;
10216   else if (longlong)
10217     type = long_long_integer_type_node;
10218   else if (RIDBIT_SETP (RID_LONG, specbits))
10219     type = long_integer_type_node;
10220   else if (RIDBIT_SETP (RID_SHORT, specbits))
10221     type = short_integer_type_node;
10222
10223   if (RIDBIT_SETP (RID_COMPLEX, specbits))
10224     {
10225       /* If we just have "complex", it is equivalent to
10226          "complex double", but if any modifiers at all are specified it is
10227          the complex form of TYPE.  E.g, "complex short" is
10228          "complex short int".  */
10229
10230       if (defaulted_int && ! longlong
10231           && ! (RIDBIT_SETP (RID_LONG, specbits)
10232                 || RIDBIT_SETP (RID_SHORT, specbits)
10233                 || RIDBIT_SETP (RID_SIGNED, specbits)
10234                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
10235         type = complex_double_type_node;
10236       else if (type == integer_type_node)
10237         type = complex_integer_type_node;
10238       else if (type == float_type_node)
10239         type = complex_float_type_node;
10240       else if (type == double_type_node)
10241         type = complex_double_type_node;
10242       else if (type == long_double_type_node)
10243         type = complex_long_double_type_node;
10244       else
10245         type = build_complex_type (type);
10246     }
10247
10248   if (sfk == sfk_conversion
10249       && (RIDBIT_SETP (RID_CONST, specbits)
10250           || RIDBIT_SETP (RID_VOLATILE, specbits)
10251           || RIDBIT_SETP (RID_RESTRICT, specbits)))
10252     cp_error ("qualifiers are not allowed on declaration of `operator %T'",
10253               ctor_return_type);
10254
10255   /* Set CONSTP if this declaration is `const', whether by
10256      explicit specification or via a typedef.
10257      Likewise for VOLATILEP.  */
10258
10259   constp = !! RIDBIT_SETP (RID_CONST, specbits) + CP_TYPE_CONST_P (type);
10260   restrictp =
10261     !! RIDBIT_SETP (RID_RESTRICT, specbits) + CP_TYPE_RESTRICT_P (type);
10262   volatilep =
10263     !! RIDBIT_SETP (RID_VOLATILE, specbits) + CP_TYPE_VOLATILE_P (type);
10264   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10265                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10266                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10267   type = cp_build_qualified_type (type, type_quals);
10268   staticp = 0;
10269   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
10270   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
10271   RIDBIT_RESET (RID_VIRTUAL, specbits);
10272   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
10273   RIDBIT_RESET (RID_EXPLICIT, specbits);
10274
10275   if (RIDBIT_SETP (RID_STATIC, specbits))
10276     staticp = 1 + (decl_context == FIELD);
10277
10278   if (virtualp && staticp == 2)
10279     {
10280       cp_error ("member `%D' cannot be declared both virtual and static",
10281                 dname);
10282       staticp = 0;
10283     }
10284   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
10285   RIDBIT_RESET (RID_FRIEND, specbits);
10286
10287   /* Warn if two storage classes are given. Default to `auto'.  */
10288
10289   if (RIDBIT_ANY_SET (specbits))
10290     {
10291       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
10292       if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
10293       if (decl_context == PARM && nclasses > 0)
10294         error ("storage class specifiers invalid in parameter declarations");
10295       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10296         {
10297           if (decl_context == PARM)
10298             error ("typedef declaration invalid in parameter declaration");
10299           nclasses++;
10300         }
10301       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
10302       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
10303     }
10304
10305   /* Give error if `virtual' is used outside of class declaration.  */
10306   if (virtualp
10307       && (current_class_name == NULL_TREE || decl_context != FIELD))
10308     {
10309       error ("virtual outside class declaration");
10310       virtualp = 0;
10311     }
10312
10313   /* Static anonymous unions are dealt with here.  */
10314   if (staticp && decl_context == TYPENAME
10315       && TREE_CODE (declspecs) == TREE_LIST
10316       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
10317     decl_context = FIELD;
10318
10319   /* Warn about storage classes that are invalid for certain
10320      kinds of declarations (parameters, typenames, etc.).  */
10321
10322   if (nclasses > 1)
10323     error ("multiple storage classes in declaration of `%s'", name);
10324   else if (decl_context != NORMAL && nclasses > 0)
10325     {
10326       if ((decl_context == PARM || decl_context == CATCHPARM)
10327           && (RIDBIT_SETP (RID_REGISTER, specbits)
10328               || RIDBIT_SETP (RID_AUTO, specbits)))
10329         ;
10330       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10331         ;
10332       else if (decl_context == FIELD
10333                /* C++ allows static class elements  */
10334                && RIDBIT_SETP (RID_STATIC, specbits))
10335         /* C++ also allows inlines and signed and unsigned elements,
10336            but in those cases we don't come in here.  */
10337         ;
10338       else
10339         {
10340           if (decl_context == FIELD)
10341             {
10342               tree tmp = NULL_TREE;
10343               register int op = 0;
10344
10345               if (declarator)
10346                 {
10347                   /* Avoid trying to get an operand off an identifier node.  */
10348                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10349                     tmp = declarator;
10350                   else
10351                     tmp = TREE_OPERAND (declarator, 0);
10352                   op = IDENTIFIER_OPNAME_P (tmp);
10353                   if (IDENTIFIER_TYPENAME_P (tmp))
10354                     {
10355                       if (IDENTIFIER_GLOBAL_VALUE (tmp)
10356                           && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (tmp))
10357                               == TYPE_DECL))
10358                         name = IDENTIFIER_POINTER (tmp);
10359                       else
10360                         name = "<invalid operator>";
10361                     }
10362                 }
10363               error ("storage class specified for %s `%s'",
10364                      op ? "member operator" : "field",
10365                      name);
10366             }
10367           else
10368             {
10369               if (decl_context == PARM || decl_context == CATCHPARM)
10370                 error ("storage class specified for parameter `%s'", name);
10371               else
10372                 error ("storage class specified for typename");
10373             }
10374           RIDBIT_RESET (RID_REGISTER, specbits);
10375           RIDBIT_RESET (RID_AUTO, specbits);
10376           RIDBIT_RESET (RID_EXTERN, specbits);
10377         }
10378     }
10379   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10380     {
10381       if (toplevel_bindings_p ())
10382         {
10383           /* It's common practice (and completely valid) to have a const
10384              be initialized and declared extern.  */
10385           if (!(type_quals & TYPE_QUAL_CONST))
10386             warning ("`%s' initialized and declared `extern'", name);
10387         }
10388       else
10389         error ("`%s' has both `extern' and initializer", name);
10390     }
10391   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10392            && ! toplevel_bindings_p ())
10393     error ("nested function `%s' declared `extern'", name);
10394   else if (toplevel_bindings_p ())
10395     {
10396       if (RIDBIT_SETP (RID_AUTO, specbits))
10397         error ("top-level declaration of `%s' specifies `auto'", name);
10398     }
10399
10400   if (nclasses > 0 && friendp)
10401     error ("storage class specifiers invalid in friend function declarations");
10402
10403   /* Now figure out the structure of the declarator proper.
10404      Descend through it, creating more complex types, until we reach
10405      the declared identifier (or NULL_TREE, in an absolute declarator).  */
10406
10407   inner_attrs = NULL_TREE;
10408   ignore_attrs = 0;
10409
10410   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10411          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10412     {
10413       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10414          an INDIRECT_REF (for *...),
10415          a CALL_EXPR (for ...(...)),
10416          an identifier (for the name being declared)
10417          or a null pointer (for the place in an absolute declarator
10418          where the name was omitted).
10419          For the last two cases, we have just exited the loop.
10420
10421          For C++ it could also be
10422          a SCOPE_REF (for class :: ...).  In this case, we have converted
10423          sensible names to types, and those are the values we use to
10424          qualify the member name.
10425          an ADDR_EXPR (for &...),
10426          a BIT_NOT_EXPR (for destructors)
10427
10428          At this point, TYPE is the type of elements of an array,
10429          or for a function to return, or for a pointer to point to.
10430          After this sequence of ifs, TYPE is the type of the
10431          array or function or pointer, and DECLARATOR has had its
10432          outermost layer removed.  */
10433
10434       if (type == error_mark_node)
10435         {
10436           if (TREE_CODE (declarator) == SCOPE_REF)
10437             declarator = TREE_OPERAND (declarator, 1);
10438           else
10439             declarator = TREE_OPERAND (declarator, 0);
10440           continue;
10441         }
10442       if (quals != NULL_TREE
10443           && (declarator == NULL_TREE
10444               || TREE_CODE (declarator) != SCOPE_REF))
10445         {
10446           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10447             ctype = TYPE_METHOD_BASETYPE (type);
10448           if (ctype != NULL_TREE)
10449             {
10450               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10451               grok_method_quals (ctype, dummy, quals);
10452               type = TREE_TYPE (dummy);
10453               ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
10454               quals = NULL_TREE;
10455             }
10456         }
10457
10458       /* See the comment for the TREE_LIST case, below.  */
10459       if (ignore_attrs)
10460         ignore_attrs = 0;
10461       else if (inner_attrs)
10462         {
10463           decl_attributes (type, inner_attrs, NULL_TREE);
10464           inner_attrs = NULL_TREE;
10465         }
10466
10467       switch (TREE_CODE (declarator))
10468         {
10469         case TREE_LIST:
10470           {
10471             /* We encode a declarator with embedded attributes using
10472                a TREE_LIST.  The attributes apply to the declarator
10473                directly inside them, so we have to skip an iteration
10474                before applying them to the type.  If the declarator just
10475                inside is the declarator-id, we apply the attrs to the
10476                decl itself.  */
10477             inner_attrs = TREE_PURPOSE (declarator);
10478             ignore_attrs = 1;
10479             declarator = TREE_VALUE (declarator);
10480           }
10481           break;
10482
10483         case ARRAY_REF:
10484           {
10485             register tree size;
10486
10487             size = TREE_OPERAND (declarator, 1);
10488
10489             /* VC++ spells a zero-sized array with [].  */
10490             if (size == NULL_TREE && decl_context == FIELD && ! staticp
10491                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10492               size = integer_zero_node;
10493
10494             declarator = TREE_OPERAND (declarator, 0);
10495
10496             type = create_array_type_for_decl (dname, type, size);
10497
10498             /* VLAs never work as fields. */
10499             if (decl_context == FIELD && !processing_template_decl
10500                 && TREE_CODE (type) == ARRAY_TYPE
10501                 && TYPE_DOMAIN (type) != NULL_TREE
10502                 && !TREE_CONSTANT (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
10503               {
10504                 cp_error ("size of member `%D' is not constant", dname);
10505                 /* Proceed with arbitrary constant size, so that offset
10506                    computations don't get confused. */
10507                 type = create_array_type_for_decl (dname, TREE_TYPE (type),
10508                                                    integer_one_node);
10509               }
10510
10511             ctype = NULL_TREE;
10512           }
10513           break;
10514
10515         case CALL_EXPR:
10516           {
10517             tree arg_types;
10518             int funcdecl_p;
10519             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10520             tree inner_decl = TREE_OPERAND (declarator, 0);
10521
10522             /* Declaring a function type.
10523                Make sure we have a valid type for the function to return.  */
10524
10525             /* We now know that the TYPE_QUALS don't apply to the
10526                decl, but to its return type.  */
10527             type_quals = TYPE_UNQUALIFIED;
10528
10529             /* Warn about some types functions can't return.  */
10530
10531             if (TREE_CODE (type) == FUNCTION_TYPE)
10532               {
10533                 error ("`%s' declared as function returning a function", name);
10534                 type = integer_type_node;
10535               }
10536             if (TREE_CODE (type) == ARRAY_TYPE)
10537               {
10538                 error ("`%s' declared as function returning an array", name);
10539                 type = integer_type_node;
10540               }
10541
10542             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10543               inner_decl = TREE_OPERAND (inner_decl, 1);
10544
10545             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10546               inner_decl = dname;
10547
10548             /* Pick up type qualifiers which should be applied to `this'.  */
10549             quals = CALL_DECLARATOR_QUALS (declarator);
10550
10551             /* Pick up the exception specifications.  */
10552             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10553
10554             /* Say it's a definition only for the CALL_EXPR
10555                closest to the identifier.  */
10556             funcdecl_p
10557               = inner_decl
10558               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10559                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10560                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10561
10562             if (ctype == NULL_TREE
10563                 && decl_context == FIELD
10564                 && funcdecl_p
10565                 && (friendp == 0 || dname == current_class_name))
10566               ctype = current_class_type;
10567
10568             if (ctype && sfk == sfk_conversion)
10569               TYPE_HAS_CONVERSION (ctype) = 1;
10570             if (ctype && constructor_name (ctype) == dname)
10571               {
10572                 /* We are within a class's scope. If our declarator name
10573                    is the same as the class name, and we are defining
10574                    a function, then it is a constructor/destructor, and
10575                    therefore returns a void type.  */
10576
10577                 if (flags == DTOR_FLAG)
10578                   {
10579                     /* ISO C++ 12.4/2.  A destructor may not be
10580                        declared const or volatile.  A destructor may
10581                        not be static.  */
10582                     if (staticp == 2)
10583                       error ("destructor cannot be static member function");
10584                     if (quals)
10585                       {
10586                         cp_error ("destructors may not be `%s'",
10587                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10588                         quals = NULL_TREE;
10589                       }
10590                     if (decl_context == FIELD)
10591                       {
10592                         if (! member_function_or_else (ctype,
10593                                                        current_class_type,
10594                                                        flags))
10595                           return void_type_node;
10596                       }
10597                   }
10598                 else            /* It's a constructor.  */
10599                   {
10600                     if (explicitp == 1)
10601                       explicitp = 2;
10602                     /* ISO C++ 12.1.  A constructor may not be
10603                        declared const or volatile.  A constructor may
10604                        not be virtual.  A constructor may not be
10605                        static.  */
10606                     if (staticp == 2)
10607                       error ("constructor cannot be static member function");
10608                     if (virtualp)
10609                       {
10610                         pedwarn ("constructors cannot be declared virtual");
10611                         virtualp = 0;
10612                       }
10613                     if (quals)
10614                       {
10615                         cp_error ("constructors may not be `%s'",
10616                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10617                         quals = NULL_TREE;
10618                       }
10619                     {
10620                       RID_BIT_TYPE tmp_bits;
10621                       bcopy ((void*)&specbits, (void*)&tmp_bits, sizeof (RID_BIT_TYPE));
10622                       RIDBIT_RESET (RID_INLINE, tmp_bits);
10623                       RIDBIT_RESET (RID_STATIC, tmp_bits);
10624                       if (RIDBIT_ANY_SET (tmp_bits))
10625                         error ("return value type specifier for constructor ignored");
10626                     }
10627                     if (decl_context == FIELD)
10628                       {
10629                         if (! member_function_or_else (ctype,
10630                                                        current_class_type,
10631                                                        flags))
10632                           return void_type_node;
10633                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10634                         if (sfk != sfk_constructor)
10635                           return NULL_TREE;
10636                       }
10637                   }
10638                 if (decl_context == FIELD)
10639                   staticp = 0;
10640               }
10641             else if (friendp)
10642               {
10643                 if (initialized)
10644                   error ("can't initialize friend function `%s'", name);
10645                 if (virtualp)
10646                   {
10647                     /* Cannot be both friend and virtual.  */
10648                     error ("virtual functions cannot be friends");
10649                     RIDBIT_RESET (RID_FRIEND, specbits);
10650                     friendp = 0;
10651                   }
10652                 if (decl_context == NORMAL)
10653                   error ("friend declaration not in class definition");
10654                 if (current_function_decl && funcdef_flag)
10655                   cp_error ("can't define friend function `%s' in a local class definition",
10656                             name);
10657               }
10658
10659             /* Construct the function type and go to the next
10660                inner layer of declarator.  */
10661
10662             declarator = TREE_OPERAND (declarator, 0);
10663
10664             /* FIXME: This is where default args should be fully
10665                processed.  */
10666
10667             arg_types = grokparms (inner_parms, funcdecl_p ? funcdef_flag : 0);
10668
10669             if (declarator && flags == DTOR_FLAG)
10670               {
10671                 /* A destructor declared in the body of a class will
10672                    be represented as a BIT_NOT_EXPR.  But, we just
10673                    want the underlying IDENTIFIER.  */
10674                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10675                   declarator = TREE_OPERAND (declarator, 0);
10676
10677                 if (strict_prototype == 0 && arg_types == NULL_TREE)
10678                   arg_types = void_list_node;
10679                 else if (arg_types == NULL_TREE
10680                          || arg_types != void_list_node)
10681                   {
10682                     cp_error ("destructors may not have parameters");
10683                     arg_types = void_list_node;
10684                     last_function_parms = NULL_TREE;
10685                   }
10686               }
10687
10688             /* ANSI says that `const int foo ();'
10689                does not make the function foo const.  */
10690             type = build_function_type (type, arg_types);
10691
10692             {
10693               tree t;
10694               for (t = arg_types; t; t = TREE_CHAIN (t))
10695                 if (TREE_PURPOSE (t)
10696                     && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10697                   {
10698                     add_defarg_fn (type);
10699                     break;
10700                   }
10701             }
10702           }
10703           break;
10704
10705         case ADDR_EXPR:
10706         case INDIRECT_REF:
10707           /* Filter out pointers-to-references and references-to-references.
10708              We can get these if a TYPE_DECL is used.  */
10709
10710           if (TREE_CODE (type) == REFERENCE_TYPE)
10711             {
10712               error ("cannot declare %s to references",
10713                      TREE_CODE (declarator) == ADDR_EXPR
10714                      ? "references" : "pointers");
10715               declarator = TREE_OPERAND (declarator, 0);
10716               continue;
10717             }
10718
10719           if (TREE_CODE (type) == OFFSET_TYPE
10720               && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10721                   || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10722             {
10723               cp_error ("cannot declare pointer to `%#T' member",
10724                         TREE_TYPE (type));
10725               type = TREE_TYPE (type);
10726             }
10727
10728           /* Merge any constancy or volatility into the target type
10729              for the pointer.  */
10730
10731           /* We now know that the TYPE_QUALS don't apply to the decl,
10732              but to the target of the pointer.  */
10733           type_quals = TYPE_UNQUALIFIED;
10734
10735           if (TREE_CODE (declarator) == ADDR_EXPR)
10736             {
10737               if (TREE_CODE (type) == VOID_TYPE)
10738                 error ("invalid type: `void &'");
10739               else
10740                 type = build_reference_type (type);
10741             }
10742           else if (TREE_CODE (type) == METHOD_TYPE)
10743             type = build_ptrmemfunc_type (build_pointer_type (type));
10744           else
10745             type = build_pointer_type (type);
10746
10747           /* Process a list of type modifier keywords (such as
10748              const or volatile) that were given inside the `*' or `&'.  */
10749
10750           if (TREE_TYPE (declarator))
10751             {
10752               register tree typemodlist;
10753               int erred = 0;
10754
10755               constp = 0;
10756               volatilep = 0;
10757               restrictp = 0;
10758               for (typemodlist = TREE_TYPE (declarator); typemodlist;
10759                    typemodlist = TREE_CHAIN (typemodlist))
10760                 {
10761                   tree qualifier = TREE_VALUE (typemodlist);
10762
10763                   if (qualifier == ridpointers[(int) RID_CONST])
10764                     constp++;
10765                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
10766                     volatilep++;
10767                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
10768                     restrictp++;
10769                   else if (!erred)
10770                     {
10771                       erred = 1;
10772                       error ("invalid type modifier within pointer declarator");
10773                     }
10774                 }
10775               if (constp > 1)
10776                 pedwarn ("duplicate `const'");
10777               if (volatilep > 1)
10778                 pedwarn ("duplicate `volatile'");
10779               if (restrictp > 1)
10780                 pedwarn ("duplicate `restrict'");
10781
10782               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10783                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10784                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10785               if (TREE_CODE (declarator) == ADDR_EXPR
10786                   && (constp || volatilep))
10787                 {
10788                   if (constp)
10789                     pedwarn ("discarding `const' applied to a reference");
10790                   if (volatilep)
10791                     pedwarn ("discarding `volatile' applied to a reference");
10792                   type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
10793                 }
10794               type = cp_build_qualified_type (type, type_quals);
10795             }
10796           declarator = TREE_OPERAND (declarator, 0);
10797           ctype = NULL_TREE;
10798           break;
10799
10800         case SCOPE_REF:
10801           {
10802             /* We have converted type names to NULL_TREE if the
10803                name was bogus, or to a _TYPE node, if not.
10804
10805                The variable CTYPE holds the type we will ultimately
10806                resolve to.  The code here just needs to build
10807                up appropriate member types.  */
10808             tree sname = TREE_OPERAND (declarator, 1);
10809             tree t;
10810
10811             /* Destructors can have their visibilities changed as well.  */
10812             if (TREE_CODE (sname) == BIT_NOT_EXPR)
10813               sname = TREE_OPERAND (sname, 0);
10814
10815             if (TREE_COMPLEXITY (declarator) == 0)
10816               /* This needs to be here, in case we are called
10817                  multiple times.  */ ;
10818             else if (TREE_COMPLEXITY (declarator) == -1)
10819               /* Namespace member. */
10820               pop_decl_namespace ();
10821             else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
10822               /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10823             else if (! IS_AGGR_TYPE_CODE
10824                      (TREE_CODE (TREE_OPERAND (declarator, 0))))
10825               ;
10826             else if (TREE_COMPLEXITY (declarator) == current_class_depth)
10827               {
10828                 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10829                    that refer to ctype.  They couldn't be resolved earlier
10830                    because we hadn't pushed into the class yet.
10831                    Example: resolve 'B<T>::type' in
10832                    'B<typename B<T>::type> B<T>::f () { }'.  */
10833                 if (current_template_parms
10834                     && uses_template_parms (type)
10835                     && uses_template_parms (current_class_type))
10836                   {
10837                     tree args = current_template_args ();
10838                     type = tsubst (type, args, /*complain=*/1, NULL_TREE);
10839                   }
10840
10841                 /* This pop_nested_class corresponds to the
10842                    push_nested_class used to push into class scope for
10843                    parsing the argument list of a function decl, in
10844                    qualified_id.  */
10845                 pop_nested_class ();
10846                 TREE_COMPLEXITY (declarator) = current_class_depth;
10847               }
10848             else
10849               my_friendly_abort (16);
10850
10851             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
10852               {
10853                 /* We had a reference to a global decl, or
10854                    perhaps we were given a non-aggregate typedef,
10855                    in which case we cleared this out, and should just
10856                    keep going as though it wasn't there.  */
10857                 declarator = sname;
10858                 continue;
10859               }
10860             ctype = TREE_OPERAND (declarator, 0);
10861
10862             t = ctype;
10863             while (t != NULL_TREE && CLASS_TYPE_P (t))
10864               {
10865                 /* You're supposed to have one `template <...>'
10866                    for every template class, but you don't need one
10867                    for a full specialization.  For example:
10868
10869                      template <class T> struct S{};
10870                      template <> struct S<int> { void f(); };
10871                      void S<int>::f () {}
10872
10873                    is correct; there shouldn't be a `template <>' for
10874                    the definition of `S<int>::f'.  */
10875                 if (CLASSTYPE_TEMPLATE_INFO (t)
10876                     && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
10877                         || uses_template_parms (CLASSTYPE_TI_ARGS (t))))
10878                   template_count += 1;
10879
10880                 t = TYPE_MAIN_DECL (t);
10881                 if (DECL_LANG_SPECIFIC (t))
10882                   t = DECL_CONTEXT (t);
10883                 else
10884                   t = NULL_TREE;
10885               }
10886
10887             if (sname == NULL_TREE)
10888               goto done_scoping;
10889
10890             if (TREE_CODE (sname) == IDENTIFIER_NODE)
10891               {
10892                 /* This is the `standard' use of the scoping operator:
10893                    basetype :: member .  */
10894
10895                 if (ctype == current_class_type)
10896                   {
10897                     /* class A {
10898                          void A::f ();
10899                        };
10900
10901                        Is this ill-formed?  */
10902
10903                     if (pedantic)
10904                       cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10905                                   ctype, name);
10906                   }
10907                 else if (TREE_CODE (type) == FUNCTION_TYPE)
10908                   {
10909                     if (current_class_type == NULL_TREE
10910                         || friendp)
10911                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10912                                                       TYPE_ARG_TYPES (type));
10913                     else
10914                       {
10915                         cp_error ("cannot declare member function `%T::%s' within `%T'",
10916                                   ctype, name, current_class_type);
10917                         return void_type_node;
10918                       }
10919                   }
10920                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
10921                          || COMPLETE_TYPE_P (complete_type (ctype)))
10922                   {
10923                     /* Have to move this code elsewhere in this function.
10924                        this code is used for i.e., typedef int A::M; M *pm;
10925
10926                        It is?  How? jason 10/2/94 */
10927
10928                     if (current_class_type)
10929                       {
10930                         cp_error ("cannot declare member `%T::%s' within `%T'",
10931                                   ctype, name, current_class_type);
10932                         return void_type_node;
10933                       }
10934                     type = build_offset_type (ctype, type);
10935                   }
10936                 else if (uses_template_parms (ctype))
10937                   {
10938                     if (TREE_CODE (type) == FUNCTION_TYPE)
10939                       type
10940                         = build_cplus_method_type (ctype, TREE_TYPE (type),
10941                                                    TYPE_ARG_TYPES (type));
10942                   }
10943                 else
10944                   {
10945                     cp_error ("structure `%T' not yet defined", ctype);
10946                     return error_mark_node;
10947                   }
10948
10949                 declarator = sname;
10950               }
10951             else if (TREE_CODE (sname) == SCOPE_REF)
10952               my_friendly_abort (17);
10953             else
10954               {
10955               done_scoping:
10956                 declarator = TREE_OPERAND (declarator, 1);
10957                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
10958                   /* In this case, we will deal with it later.  */
10959                   ;
10960                 else
10961                   {
10962                     if (TREE_CODE (type) == FUNCTION_TYPE)
10963                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10964                                                       TYPE_ARG_TYPES (type));
10965                     else
10966                       type = build_offset_type (ctype, type);
10967                   }
10968               }
10969           }
10970           break;
10971
10972         case BIT_NOT_EXPR:
10973           declarator = TREE_OPERAND (declarator, 0);
10974           break;
10975
10976         case RECORD_TYPE:
10977         case UNION_TYPE:
10978         case ENUMERAL_TYPE:
10979           declarator = NULL_TREE;
10980           break;
10981
10982         case ERROR_MARK:
10983           declarator = NULL_TREE;
10984           break;
10985
10986         default:
10987           my_friendly_abort (158);
10988         }
10989     }
10990
10991   /* See the comment for the TREE_LIST case, above.  */
10992   if (inner_attrs)
10993     {
10994       if (! ignore_attrs)
10995         decl_attributes (type, inner_attrs, NULL_TREE);
10996       else if (attrlist)
10997         TREE_VALUE (attrlist) = chainon (inner_attrs, TREE_VALUE (attrlist));
10998       else
10999         attrlist = build_decl_list (NULL_TREE, inner_attrs);
11000     }
11001
11002   /* Now TYPE has the actual type.  */
11003
11004   if (explicitp == 1 || (explicitp && friendp))
11005     {
11006       /* [dcl.fct.spec] The explicit specifier shall only be used in
11007          declarations of constructors within a class definition.  */
11008       error ("only declarations of constructors can be `explicit'");
11009       explicitp = 0;
11010     }
11011
11012   if (RIDBIT_SETP (RID_MUTABLE, specbits))
11013     {
11014       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
11015         {
11016           error ("non-member `%s' cannot be declared `mutable'", name);
11017           RIDBIT_RESET (RID_MUTABLE, specbits);
11018         }
11019       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
11020         {
11021           error ("non-object member `%s' cannot be declared `mutable'", name);
11022           RIDBIT_RESET (RID_MUTABLE, specbits);
11023         }
11024       else if (TREE_CODE (type) == FUNCTION_TYPE
11025                || TREE_CODE (type) == METHOD_TYPE)
11026         {
11027           error ("function `%s' cannot be declared `mutable'", name);
11028           RIDBIT_RESET (RID_MUTABLE, specbits);
11029         }
11030       else if (staticp)
11031         {
11032           error ("static `%s' cannot be declared `mutable'", name);
11033           RIDBIT_RESET (RID_MUTABLE, specbits);
11034         }
11035       else if (type_quals & TYPE_QUAL_CONST)
11036         {
11037           error ("const `%s' cannot be declared `mutable'", name);
11038           RIDBIT_RESET (RID_MUTABLE, specbits);
11039         }
11040     }
11041
11042   if (declarator == NULL_TREE
11043       || TREE_CODE (declarator) == IDENTIFIER_NODE
11044       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
11045           && (TREE_CODE (type) == FUNCTION_TYPE
11046               || TREE_CODE (type) == METHOD_TYPE)))
11047     /* OK */;
11048   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11049     {
11050       cp_error ("template-id `%D' used as a declarator", declarator);
11051       declarator = dname;
11052     }
11053   else
11054     /* Unexpected declarator format.  */
11055     my_friendly_abort (990210);
11056
11057   /* If this is declaring a typedef name, return a TYPE_DECL.  */
11058
11059   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
11060     {
11061       tree decl;
11062
11063       /* Note that the grammar rejects storage classes
11064          in typenames, fields or parameters.  */
11065       if (current_lang_name == lang_name_java)
11066         TYPE_FOR_JAVA (type) = 1;
11067
11068       if (decl_context == FIELD)
11069         {
11070           if (declarator == constructor_name (current_class_type))
11071             cp_pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
11072                         declarator);
11073           decl = build_lang_decl (TYPE_DECL, declarator, type);
11074         }
11075       else
11076         decl = build_decl (TYPE_DECL, declarator, type);
11077
11078       /* If the user declares "typedef struct {...} foo" then the
11079          struct will have an anonymous name.  Fill that name in now.
11080          Nothing can refer to it, so nothing needs know about the name
11081          change.  */
11082       if (type != error_mark_node
11083           && declarator
11084           && TYPE_NAME (type)
11085           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11086           && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type))
11087           && CP_TYPE_QUALS (type) == TYPE_UNQUALIFIED)
11088         {
11089           tree oldname = TYPE_NAME (type);
11090           tree t;
11091
11092           /* Replace the anonymous name with the real name everywhere.  */
11093           lookup_tag_reverse (type, declarator);
11094           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
11095             if (TYPE_NAME (t) == oldname)
11096               TYPE_NAME (t) = decl;
11097
11098           if (TYPE_LANG_SPECIFIC (type))
11099             TYPE_WAS_ANONYMOUS (type) = 1;
11100
11101           /* If this is a typedef within a template class, the nested
11102              type is a (non-primary) template.  The name for the
11103              template needs updating as well.  */
11104           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
11105             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
11106               = TYPE_IDENTIFIER (type);
11107
11108           if (flag_new_abi)
11109             DECL_ASSEMBLER_NAME (decl) = mangle_type (type);
11110           else
11111             {
11112               /* XXX Temporarily set the scope.
11113                  When returning, start_decl expects it as NULL_TREE,
11114                  and will then then set it using pushdecl. */
11115               my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 980404);
11116               if (current_class_type)
11117                 DECL_CONTEXT (decl) = current_class_type;
11118               else
11119                 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
11120
11121               DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
11122               DECL_ASSEMBLER_NAME (decl)
11123                 = get_identifier (build_overload_name (type, 1, 1));
11124               DECL_CONTEXT (decl) = NULL_TREE;
11125             }
11126
11127           /* FIXME remangle member functions; member functions of a
11128              type with external linkage have external linkage.  */
11129         }
11130
11131       if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
11132         {
11133           cp_error_at ("typedef name may not be class-qualified", decl);
11134           return NULL_TREE;
11135         }
11136       else if (quals)
11137         {
11138           if (ctype == NULL_TREE)
11139             {
11140               if (TREE_CODE (type) != METHOD_TYPE)
11141                 cp_error_at ("invalid type qualifier for non-member function type", decl);
11142               else
11143                 ctype = TYPE_METHOD_BASETYPE (type);
11144             }
11145           if (ctype != NULL_TREE)
11146             grok_method_quals (ctype, decl, quals);
11147         }
11148
11149       if (RIDBIT_SETP (RID_SIGNED, specbits)
11150           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
11151         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
11152
11153       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
11154                       inlinep, friendp, raises != NULL_TREE);
11155
11156       if (initialized)
11157         error ("typedef declaration includes an initializer");
11158
11159       return decl;
11160     }
11161
11162   /* Detect the case of an array type of unspecified size
11163      which came, as such, direct from a typedef name.
11164      We must copy the type, so that each identifier gets
11165      a distinct type, so that each identifier's size can be
11166      controlled separately by its own initializer.  */
11167
11168   if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
11169       && TYPE_DOMAIN (type) == NULL_TREE)
11170     {
11171       type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
11172     }
11173
11174   /* If this is a type name (such as, in a cast or sizeof),
11175      compute the type and return it now.  */
11176
11177   if (decl_context == TYPENAME)
11178     {
11179       /* Note that the grammar rejects storage classes
11180          in typenames, fields or parameters.  */
11181       if (type_quals != TYPE_UNQUALIFIED)
11182         type_quals = TYPE_UNQUALIFIED;
11183
11184       /* Special case: "friend class foo" looks like a TYPENAME context.  */
11185       if (friendp)
11186         {
11187           if (type_quals != TYPE_UNQUALIFIED)
11188             {
11189               cp_error ("type qualifiers specified for friend class declaration");
11190               type_quals = TYPE_UNQUALIFIED;
11191             }
11192           if (inlinep)
11193             {
11194               cp_error ("`inline' specified for friend class declaration");
11195               inlinep = 0;
11196             }
11197
11198           /* Only try to do this stuff if we didn't already give up.  */
11199           if (type != integer_type_node)
11200             {
11201               /* A friendly class?  */
11202               if (current_class_type)
11203                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
11204               else
11205                 error ("trying to make class `%s' a friend of global scope",
11206                        TYPE_NAME_STRING (type));
11207               type = void_type_node;
11208             }
11209         }
11210       else if (quals)
11211         {
11212           if (ctype == NULL_TREE)
11213             {
11214               if (TREE_CODE (type) != METHOD_TYPE)
11215                 cp_error ("invalid qualifiers on non-member function type");
11216               else
11217                 ctype = TYPE_METHOD_BASETYPE (type);
11218             }
11219           if (ctype)
11220             {
11221               tree dummy = build_decl (TYPE_DECL, declarator, type);
11222               grok_method_quals (ctype, dummy, quals);
11223               type = TREE_TYPE (dummy);
11224             }
11225         }
11226
11227       return type;
11228     }
11229   else if (declarator == NULL_TREE && decl_context != PARM
11230            && decl_context != CATCHPARM
11231            && TREE_CODE (type) != UNION_TYPE
11232            && ! bitfield)
11233     {
11234       cp_error ("abstract declarator `%T' used as declaration", type);
11235       declarator = make_anon_name ();
11236     }
11237
11238   /* `void' at top level (not within pointer)
11239      is allowed only in typedefs or type names.
11240      We don't complain about parms either, but that is because
11241      a better error message can be made later.  */
11242
11243   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
11244     {
11245       if (! declarator)
11246         error ("unnamed variable or field declared void");
11247       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
11248         {
11249           if (IDENTIFIER_OPNAME_P (declarator))
11250             my_friendly_abort (356);
11251           else
11252             error ("variable or field `%s' declared void", name);
11253         }
11254       else
11255         error ("variable or field declared void");
11256       type = integer_type_node;
11257     }
11258
11259   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11260      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
11261
11262   if (decl_context == PARM || decl_context == CATCHPARM)
11263     {
11264       if (ctype || in_namespace)
11265         error ("cannot use `::' in parameter declaration");
11266
11267       /* A parameter declared as an array of T is really a pointer to T.
11268          One declared as a function is really a pointer to a function.
11269          One declared as a member is really a pointer to member.  */
11270
11271       if (TREE_CODE (type) == ARRAY_TYPE)
11272         {
11273           /* Transfer const-ness of array into that of type pointed to.  */
11274           type = build_pointer_type (TREE_TYPE (type));
11275           type_quals = TYPE_UNQUALIFIED;
11276         }
11277       else if (TREE_CODE (type) == FUNCTION_TYPE)
11278         type = build_pointer_type (type);
11279       else if (TREE_CODE (type) == OFFSET_TYPE)
11280         type = build_pointer_type (type);
11281       else if (TREE_CODE (type) == VOID_TYPE && declarator)
11282         {
11283           error ("declaration of `%s' as void", name);
11284           return NULL_TREE;
11285         }
11286     }
11287
11288   {
11289     register tree decl;
11290
11291     if (decl_context == PARM)
11292       {
11293         decl = build_decl (PARM_DECL, declarator, type);
11294
11295         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
11296                         inlinep, friendp, raises != NULL_TREE);
11297
11298         /* Compute the type actually passed in the parmlist,
11299            for the case where there is no prototype.
11300            (For example, shorts and chars are passed as ints.)
11301            When there is a prototype, this is overridden later.  */
11302
11303         DECL_ARG_TYPE (decl) = type_promotes_to (type);
11304       }
11305     else if (decl_context == FIELD)
11306       {
11307         if (type == error_mark_node)
11308           {
11309             /* Happens when declaring arrays of sizes which
11310                are error_mark_node, for example.  */
11311             decl = NULL_TREE;
11312           }
11313         else if (in_namespace && !friendp)
11314           {
11315             /* Something like struct S { int N::j; };  */
11316             cp_error ("invalid use of `::'");
11317             decl = NULL_TREE;
11318           }
11319         else if (TREE_CODE (type) == FUNCTION_TYPE)
11320           {
11321             int publicp = 0;
11322             tree function_context;
11323
11324             /* We catch the others as conflicts with the builtin
11325                typedefs.  */
11326             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11327               {
11328                 cp_error ("function `%D' cannot be declared friend",
11329                           declarator);
11330                 friendp = 0;
11331               }
11332
11333             if (friendp == 0)
11334               {
11335                 if (ctype == NULL_TREE)
11336                   ctype = current_class_type;
11337
11338                 if (ctype == NULL_TREE)
11339                   {
11340                     cp_error ("can't make `%D' into a method -- not in a class",
11341                               declarator);
11342                     return void_type_node;
11343                   }
11344
11345                 /* ``A union may [ ... ] not [ have ] virtual functions.''
11346                    ARM 9.5 */
11347                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11348                   {
11349                     cp_error ("function `%D' declared virtual inside a union",
11350                               declarator);
11351                     return void_type_node;
11352                   }
11353
11354                 if (declarator == ansi_opname (NEW_EXPR)
11355                     || declarator == ansi_opname (VEC_NEW_EXPR)
11356                     || declarator == ansi_opname (DELETE_EXPR)
11357                     || declarator == ansi_opname (VEC_DELETE_EXPR))
11358                   {
11359                     if (virtualp)
11360                       {
11361                         cp_error ("`%D' cannot be declared virtual, since it is always static",
11362                                   declarator);
11363                         virtualp = 0;
11364                       }
11365                   }
11366                 else if (staticp < 2)
11367                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11368                                                   TYPE_ARG_TYPES (type));
11369               }
11370
11371             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
11372             function_context = (ctype != NULL_TREE) ?
11373               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11374             publicp = (! friendp || ! staticp)
11375               && function_context == NULL_TREE;
11376             decl = grokfndecl (ctype, type,
11377                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11378                                ? declarator : dname,
11379                                declarator,
11380                                virtualp, flags, quals, raises,
11381                                friendp ? -1 : 0, friendp, publicp, inlinep,
11382                                funcdef_flag, template_count, in_namespace);
11383             if (decl == NULL_TREE)
11384               return decl;
11385 #if 0
11386             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
11387             /* The decl and setting of decl_machine_attr is also turned off.  */
11388             decl = build_decl_attribute_variant (decl, decl_machine_attr);
11389 #endif
11390
11391             /* [class.conv.ctor]
11392
11393                A constructor declared without the function-specifier
11394                explicit that can be called with a single parameter
11395                specifies a conversion from the type of its first
11396                parameter to the type of its class.  Such a constructor
11397                is called a converting constructor.  */
11398             if (explicitp == 2)
11399               DECL_NONCONVERTING_P (decl) = 1;
11400             else if (DECL_CONSTRUCTOR_P (decl))
11401               {
11402                 /* The constructor can be called with exactly one
11403                    parameter if there is at least one parameter, and
11404                    any subsequent parameters have default arguments.
11405                    We don't look at the first parameter, which is
11406                    really just the `this' parameter for the new
11407                    object.  */
11408                 tree arg_types =
11409                   TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)));
11410
11411                 /* Skip the `in_chrg' argument too, if present.  */
11412                 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
11413                   arg_types = TREE_CHAIN (arg_types);
11414
11415                 if (arg_types == void_list_node
11416                     || (arg_types
11417                         && TREE_CHAIN (arg_types)
11418                         && TREE_CHAIN (arg_types) != void_list_node
11419                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11420                   DECL_NONCONVERTING_P (decl) = 1;
11421               }
11422           }
11423         else if (TREE_CODE (type) == METHOD_TYPE)
11424           {
11425             /* We only get here for friend declarations of
11426                members of other classes.  */
11427             /* All method decls are public, so tell grokfndecl to set
11428                TREE_PUBLIC, also.  */
11429             decl = grokfndecl (ctype, type, declarator, declarator,
11430                                virtualp, flags, quals, raises,
11431                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11432                                template_count, in_namespace);
11433             if (decl == NULL_TREE)
11434               return NULL_TREE;
11435           }
11436         else if (!staticp && ! processing_template_decl
11437                  && !COMPLETE_TYPE_P (complete_type (type))
11438                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11439           {
11440             if (declarator)
11441               cp_error ("field `%D' has incomplete type", declarator);
11442             else
11443               cp_error ("name `%T' has incomplete type", type);
11444
11445             /* If we're instantiating a template, tell them which
11446                instantiation made the field's type be incomplete.  */
11447             if (current_class_type
11448                 && TYPE_NAME (current_class_type)
11449                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11450                 && declspecs && TREE_VALUE (declspecs)
11451                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11452               cp_error ("  in instantiation of template `%T'",
11453                         current_class_type);
11454
11455             type = error_mark_node;
11456             decl = NULL_TREE;
11457           }
11458         else
11459           {
11460             if (friendp)
11461               {
11462                 error ("`%s' is neither function nor member function; cannot be declared friend",
11463                        IDENTIFIER_POINTER (declarator));
11464                 friendp = 0;
11465               }
11466             decl = NULL_TREE;
11467           }
11468
11469         if (friendp)
11470           {
11471             /* Friends are treated specially.  */
11472             if (ctype == current_class_type)
11473               warning ("member functions are implicitly friends of their class");
11474             else
11475               {
11476                 tree t = NULL_TREE;
11477                 if (decl && DECL_NAME (decl))
11478                   {
11479                     if (template_class_depth (current_class_type) == 0)
11480                       {
11481                         decl
11482                           = check_explicit_specialization
11483                           (declarator, decl,
11484                            template_count, 2 * (funcdef_flag != 0) + 4);
11485                         if (decl == error_mark_node)
11486                           return error_mark_node;
11487                       }
11488
11489                     t = do_friend (ctype, declarator, decl,
11490                                    last_function_parms, attrlist, flags, quals,
11491                                    funcdef_flag);
11492                   }
11493                 if (t && funcdef_flag)
11494                   return t;
11495
11496                 return void_type_node;
11497               }
11498           }
11499
11500         /* Structure field.  It may not be a function, except for C++ */
11501
11502         if (decl == NULL_TREE)
11503           {
11504             if (initialized)
11505               {
11506                 if (!staticp)
11507                   {
11508                     /* An attempt is being made to initialize a non-static
11509                        member.  But, from [class.mem]:
11510
11511                        4 A member-declarator can contain a
11512                        constant-initializer only if it declares a static
11513                        member (_class.static_) of integral or enumeration
11514                        type, see _class.static.data_.
11515
11516                        This used to be relatively common practice, but
11517                        the rest of the compiler does not correctly
11518                        handle the initialization unless the member is
11519                        static so we make it static below.  */
11520                     cp_pedwarn ("ISO C++ forbids initialization of member `%D'",
11521                                 declarator);
11522                     cp_pedwarn ("making `%D' static", declarator);
11523                     staticp = 1;
11524                   }
11525
11526                 if (uses_template_parms (type))
11527                   /* We'll check at instantiation time.  */
11528                   ;
11529                 else if (check_static_variable_definition (declarator,
11530                                                            type))
11531                   /* If we just return the declaration, crashes
11532                      will sometimes occur.  We therefore return
11533                      void_type_node, as if this was a friend
11534                      declaration, to cause callers to completely
11535                      ignore this declaration.  */
11536                   return void_type_node;
11537               }
11538
11539             /* 9.2p13 [class.mem] */
11540             if (declarator == constructor_name (current_class_type)
11541                 /* The standard does not allow non-static data members
11542                    here either, but we agreed at the 10/99 meeting
11543                    to change that in TC 1 so that they are allowed in
11544                    classes with no user-defined constructors.  */
11545                 && staticp)
11546               cp_pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
11547                           declarator);
11548
11549             if (staticp)
11550               {
11551                 /* C++ allows static class members.  All other work
11552                    for this is done by grokfield.  */
11553                 decl = build_lang_decl (VAR_DECL, declarator, type);
11554                 TREE_STATIC (decl) = 1;
11555                 /* In class context, 'static' means public access.  */
11556                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11557               }
11558             else
11559               {
11560                 decl = build_decl (FIELD_DECL, declarator, type);
11561                 DECL_NONADDRESSABLE_P (decl) = bitfield;
11562                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11563                   {
11564                     DECL_MUTABLE_P (decl) = 1;
11565                     RIDBIT_RESET (RID_MUTABLE, specbits);
11566                   }
11567               }
11568
11569             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11570                             inlinep, friendp, raises != NULL_TREE);
11571           }
11572       }
11573     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11574       {
11575         tree original_name;
11576         int publicp = 0;
11577
11578         if (! declarator)
11579           return NULL_TREE;
11580
11581         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11582           original_name = dname;
11583         else
11584           original_name = declarator;
11585
11586         if (RIDBIT_SETP (RID_AUTO, specbits))
11587           error ("storage class `auto' invalid for function `%s'", name);
11588         else if (RIDBIT_SETP (RID_REGISTER, specbits))
11589           error ("storage class `register' invalid for function `%s'", name);
11590
11591         /* Function declaration not at top level.
11592            Storage classes other than `extern' are not allowed
11593            and `extern' makes no difference.  */
11594         if (! toplevel_bindings_p ()
11595             && (RIDBIT_SETP (RID_STATIC, specbits)
11596                 || RIDBIT_SETP (RID_INLINE, specbits))
11597             && pedantic)
11598           {
11599             if (RIDBIT_SETP (RID_STATIC, specbits))
11600               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11601             else
11602               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11603           }
11604
11605         if (ctype == NULL_TREE)
11606           {
11607             if (virtualp)
11608               {
11609                 error ("virtual non-class function `%s'", name);
11610                 virtualp = 0;
11611               }
11612           }
11613         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11614           type = build_cplus_method_type (ctype, TREE_TYPE (type),
11615                                           TYPE_ARG_TYPES (type));
11616
11617         /* Record presence of `static'.  */
11618         publicp = (ctype != NULL_TREE
11619                    || RIDBIT_SETP (RID_EXTERN, specbits)
11620                    || !RIDBIT_SETP (RID_STATIC, specbits));
11621
11622         decl = grokfndecl (ctype, type, original_name, declarator,
11623                            virtualp, flags, quals, raises,
11624                            1, friendp,
11625                            publicp, inlinep, funcdef_flag,
11626                            template_count, in_namespace);
11627         if (decl == NULL_TREE)
11628           return NULL_TREE;
11629
11630         if (staticp == 1)
11631           {
11632             int illegal_static = 0;
11633
11634             /* Don't allow a static member function in a class, and forbid
11635                declaring main to be static.  */
11636             if (TREE_CODE (type) == METHOD_TYPE)
11637               {
11638                 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11639                 illegal_static = 1;
11640               }
11641             else if (current_function_decl)
11642               {
11643                 /* FIXME need arm citation */
11644                 error ("cannot declare static function inside another function");
11645                 illegal_static = 1;
11646               }
11647
11648             if (illegal_static)
11649               {
11650                 staticp = 0;
11651                 RIDBIT_RESET (RID_STATIC, specbits);
11652               }
11653           }
11654       }
11655     else
11656       {
11657         /* It's a variable.  */
11658
11659         /* An uninitialized decl with `extern' is a reference.  */
11660         decl = grokvardecl (type, declarator, &specbits,
11661                             initialized,
11662                             (type_quals & TYPE_QUAL_CONST) != 0,
11663                             in_namespace);
11664         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11665                         inlinep, friendp, raises != NULL_TREE);
11666
11667         if (ctype)
11668           {
11669             DECL_CONTEXT (decl) = ctype;
11670             if (staticp == 1)
11671               {
11672                 cp_pedwarn ("static member `%D' re-declared as static", decl);
11673                 staticp = 0;
11674                 RIDBIT_RESET (RID_STATIC, specbits);
11675               }
11676             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11677               {
11678                 cp_error ("static member `%D' declared `register'", decl);
11679                 RIDBIT_RESET (RID_REGISTER, specbits);
11680               }
11681             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11682               {
11683                 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11684                             decl);
11685                 RIDBIT_RESET (RID_EXTERN, specbits);
11686               }
11687           }
11688       }
11689
11690     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11691
11692     /* Record `register' declaration for warnings on &
11693        and in case doing stupid register allocation.  */
11694
11695     if (RIDBIT_SETP (RID_REGISTER, specbits))
11696       DECL_REGISTER (decl) = 1;
11697
11698     if (RIDBIT_SETP (RID_EXTERN, specbits))
11699       DECL_THIS_EXTERN (decl) = 1;
11700
11701     if (RIDBIT_SETP (RID_STATIC, specbits))
11702       DECL_THIS_STATIC (decl) = 1;
11703
11704     /* Record constancy and volatility.  There's no need to do this
11705        when processing a template; we'll do this for the instantiated
11706        declaration based on the type of DECL.  */
11707     if (!processing_template_decl)
11708       c_apply_type_quals_to_decl (type_quals, decl);
11709
11710     return decl;
11711   }
11712 }
11713 \f
11714 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11715    An empty exprlist is a parmlist.  An exprlist which
11716    contains only identifiers at the global level
11717    is a parmlist.  Otherwise, it is an exprlist.  */
11718
11719 int
11720 parmlist_is_exprlist (exprs)
11721      tree exprs;
11722 {
11723   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11724     return 0;
11725
11726   if (toplevel_bindings_p ())
11727     {
11728       /* At the global level, if these are all identifiers,
11729          then it is a parmlist.  */
11730       while (exprs)
11731         {
11732           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11733             return 1;
11734           exprs = TREE_CHAIN (exprs);
11735         }
11736       return 0;
11737     }
11738   return 1;
11739 }
11740
11741 /* Subroutine of start_function.  Ensure that each of the parameter
11742    types (as listed in PARMS) is complete, as is required for a
11743    function definition.  */
11744
11745 static void
11746 require_complete_types_for_parms (parms)
11747      tree parms;
11748 {
11749   for (; parms; parms = TREE_CHAIN (parms))
11750     {
11751       tree type = TREE_TYPE (parms);
11752
11753       /* Try to complete the TYPE.  */
11754       type = complete_type (type);
11755
11756       if (type == error_mark_node)
11757         continue;
11758
11759       if (!COMPLETE_TYPE_P (type))
11760         {
11761           if (DECL_NAME (parms))
11762             error ("parameter `%s' has incomplete type",
11763                    IDENTIFIER_POINTER (DECL_NAME (parms)));
11764           else
11765             error ("parameter has incomplete type");
11766           TREE_TYPE (parms) = error_mark_node;
11767         }
11768       else
11769         layout_decl (parms, 0);
11770     }
11771 }
11772
11773 /* Returns non-zero if T is a local variable.  */
11774
11775 int
11776 local_variable_p (t)
11777      tree t;
11778 {
11779   if ((TREE_CODE (t) == VAR_DECL
11780        /* A VAR_DECL with a context that is a _TYPE is a static data
11781           member.  */
11782        && !TYPE_P (CP_DECL_CONTEXT (t))
11783        /* Any other non-local variable must be at namespace scope.  */
11784        && !DECL_NAMESPACE_SCOPE_P (t))
11785       || (TREE_CODE (t) == PARM_DECL))
11786     return 1;
11787
11788   return 0;
11789 }
11790
11791 /* Returns non-zero if T is an automatic local variable or a label.
11792    (These are the declarations that need to be remapped when the code
11793    containing them is duplicated.)  */
11794
11795 int
11796 nonstatic_local_decl_p (t)
11797      tree t;
11798 {
11799   return ((local_variable_p (t) && !TREE_STATIC (t))
11800           || TREE_CODE (t) == LABEL_DECL
11801           || TREE_CODE (t) == RESULT_DECL);
11802 }
11803
11804 /* Like local_variable_p, but suitable for use as a tree-walking
11805    function.  */
11806
11807 static tree
11808 local_variable_p_walkfn (tp, walk_subtrees, data)
11809      tree *tp;
11810      int *walk_subtrees ATTRIBUTE_UNUSED;
11811      void *data ATTRIBUTE_UNUSED;
11812 {
11813   return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
11814           ? *tp : NULL_TREE);
11815 }
11816
11817 /* Check that ARG, which is a default-argument expression for a
11818    parameter DECL, is legal.  Returns ARG, or ERROR_MARK_NODE, if
11819    something goes wrong.  DECL may also be a _TYPE node, rather than a
11820    DECL, if there is no DECL available.  */
11821
11822 tree
11823 check_default_argument (decl, arg)
11824      tree decl;
11825      tree arg;
11826 {
11827   tree var;
11828   tree decl_type;
11829
11830   if (TREE_CODE (arg) == DEFAULT_ARG)
11831     /* We get a DEFAULT_ARG when looking at an in-class declaration
11832        with a default argument.  Ignore the argument for now; we'll
11833        deal with it after the class is complete.  */
11834     return arg;
11835
11836   if (processing_template_decl || uses_template_parms (arg))
11837     /* We don't do anything checking until instantiation-time.  Note
11838        that there may be uninstantiated arguments even for an
11839        instantiated function, since default arguments are not
11840        instantiated until they are needed.  */
11841     return arg;
11842
11843   if (TYPE_P (decl))
11844     {
11845       decl_type = decl;
11846       decl = NULL_TREE;
11847     }
11848   else
11849     decl_type = TREE_TYPE (decl);
11850
11851   if (arg == error_mark_node
11852       || decl == error_mark_node
11853       || TREE_TYPE (arg) == error_mark_node
11854       || decl_type == error_mark_node)
11855     /* Something already went wrong.  There's no need to check
11856        further.  */
11857     return error_mark_node;
11858
11859   /* [dcl.fct.default]
11860
11861      A default argument expression is implicitly converted to the
11862      parameter type.  */
11863   if (!TREE_TYPE (arg)
11864       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
11865     {
11866       if (decl)
11867         cp_error ("default argument for `%#D' has type `%T'",
11868                   decl, TREE_TYPE (arg));
11869       else
11870         cp_error ("default argument for parameter of type `%T' has type `%T'",
11871                   decl_type, TREE_TYPE (arg));
11872
11873       return error_mark_node;
11874     }
11875
11876   /* [dcl.fct.default]
11877
11878      Local variables shall not be used in default argument
11879      expressions.
11880
11881      The keyword `this' shall not be used in a default argument of a
11882      member function.  */
11883   var = walk_tree (&arg, local_variable_p_walkfn, NULL);
11884   if (var)
11885     {
11886       cp_error ("default argument `%E' uses local variable `%D'",
11887                 arg, var);
11888       return error_mark_node;
11889     }
11890
11891   /* All is well.  */
11892   return arg;
11893 }
11894
11895 /* Decode the list of parameter types for a function type.
11896    Given the list of things declared inside the parens,
11897    return a list of types.
11898
11899    The list we receive can have three kinds of elements:
11900    an IDENTIFIER_NODE for names given without types,
11901    a TREE_LIST node for arguments given as typespecs or names with typespecs,
11902    or void_type_node, to mark the end of an argument list
11903    when additional arguments are not permitted (... was not used).
11904
11905    FUNCDEF_FLAG is nonzero for a function definition, 0 for
11906    a mere declaration.  A nonempty identifier-list gets an error message
11907    when FUNCDEF_FLAG is zero.
11908    If FUNCDEF_FLAG is 1, then parameter types must be complete.
11909    If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
11910
11911    If all elements of the input list contain types,
11912    we return a list of the types.
11913    If all elements contain no type (except perhaps a void_type_node
11914    at the end), we return a null list.
11915    If some have types and some do not, it is an error, and we
11916    return a null list.
11917
11918    Also set last_function_parms to either
11919    a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
11920    A list of names is converted to a chain of PARM_DECLs
11921    by store_parm_decls so that ultimately it is always a chain of decls.
11922
11923    Note that in C++, parameters can take default values.  These default
11924    values are in the TREE_PURPOSE field of the TREE_LIST.  It is
11925    an error to specify default values which are followed by parameters
11926    that have no default values, or an ELLIPSES.  For simplicities sake,
11927    only parameters which are specified with their types can take on
11928    default values.  */
11929
11930 static tree
11931 grokparms (first_parm, funcdef_flag)
11932      tree first_parm;
11933      int funcdef_flag;
11934 {
11935   tree result = NULL_TREE;
11936   tree decls = NULL_TREE;
11937
11938   if (first_parm != NULL_TREE
11939       && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
11940     {
11941       if (! funcdef_flag)
11942         pedwarn ("parameter names (without types) in function declaration");
11943       last_function_parms = first_parm;
11944       return NULL_TREE;
11945     }
11946   else if (first_parm != NULL_TREE
11947            && TREE_CODE (TREE_VALUE (first_parm)) != TREE_LIST
11948            && TREE_CODE (TREE_VALUE (first_parm)) != VOID_TYPE)
11949     my_friendly_abort (145);
11950   else
11951     {
11952       /* Types were specified.  This is a list of declarators
11953          each represented as a TREE_LIST node.  */
11954       register tree parm, chain;
11955       int any_init = 0, any_error = 0;
11956
11957       if (first_parm != NULL_TREE)
11958         {
11959           tree last_result = NULL_TREE;
11960           tree last_decl = NULL_TREE;
11961
11962           for (parm = first_parm; parm != NULL_TREE; parm = chain)
11963             {
11964               tree type = NULL_TREE, list_node = parm;
11965               register tree decl = TREE_VALUE (parm);
11966               tree init = TREE_PURPOSE (parm);
11967
11968               chain = TREE_CHAIN (parm);
11969               /* @@ weak defense against parse errors.  */
11970               if (TREE_CODE (decl) != VOID_TYPE
11971                   && TREE_CODE (decl) != TREE_LIST)
11972                 {
11973                   /* Give various messages as the need arises.  */
11974                   if (TREE_CODE (decl) == STRING_CST)
11975                     cp_error ("invalid string constant `%E'", decl);
11976                   else if (TREE_CODE (decl) == INTEGER_CST)
11977                     error ("invalid integer constant in parameter list, did you forget to give parameter name?");
11978                   continue;
11979                 }
11980
11981               if (TREE_CODE (decl) != VOID_TYPE)
11982                 {
11983                   decl = grokdeclarator (TREE_VALUE (decl),
11984                                          TREE_PURPOSE (decl),
11985                                          PARM, init != NULL_TREE,
11986                                          NULL_TREE);
11987                   if (! decl || TREE_TYPE (decl) == error_mark_node)
11988                     continue;
11989
11990                   /* Top-level qualifiers on the parameters are
11991                      ignored for function types.  */
11992                   type = TYPE_MAIN_VARIANT (TREE_TYPE (decl));
11993
11994                   if (TREE_CODE (type) == VOID_TYPE)
11995                     decl = void_type_node;
11996                   else if (TREE_CODE (type) == METHOD_TYPE)
11997                     {
11998                       if (DECL_NAME (decl))
11999                         /* Cannot use the decl here because
12000                            we don't have DECL_CONTEXT set up yet.  */
12001                         cp_error ("parameter `%D' invalidly declared method type",
12002                                   DECL_NAME (decl));
12003                       else
12004                         error ("parameter invalidly declared method type");
12005                       type = build_pointer_type (type);
12006                       TREE_TYPE (decl) = type;
12007                     }
12008                   else if (TREE_CODE (type) == OFFSET_TYPE)
12009                     {
12010                       if (DECL_NAME (decl))
12011                         cp_error ("parameter `%D' invalidly declared offset type",
12012                                   DECL_NAME (decl));
12013                       else
12014                         error ("parameter invalidly declared offset type");
12015                       type = build_pointer_type (type);
12016                       TREE_TYPE (decl) = type;
12017                     }
12018                   else if (abstract_virtuals_error (decl, type))
12019                     any_error = 1;  /* Seems like a good idea. */
12020                   else if (POINTER_TYPE_P (type))
12021                     {
12022                       tree t = type;
12023                       while (POINTER_TYPE_P (t)
12024                              || (TREE_CODE (t) == ARRAY_TYPE
12025                                  && TYPE_DOMAIN (t) != NULL_TREE))
12026                         t = TREE_TYPE (t);
12027                       if (TREE_CODE (t) == ARRAY_TYPE)
12028                         cp_error ("parameter type `%T' includes %s to array of unknown bound",
12029                                   type,
12030                                   TYPE_PTR_P (type) ? "pointer" : "reference");
12031                     }
12032                 }
12033
12034               if (TREE_CODE (decl) == VOID_TYPE)
12035                 {
12036                   if (result == NULL_TREE)
12037                     {
12038                       result = void_list_node;
12039                       last_result = result;
12040                     }
12041                   else
12042                     {
12043                       TREE_CHAIN (last_result) = void_list_node;
12044                       last_result = void_list_node;
12045                     }
12046                   if (chain
12047                       && (chain != void_list_node || TREE_CHAIN (chain)))
12048                     error ("`void' in parameter list must be entire list");
12049                   break;
12050                 }
12051
12052               /* Since there is a prototype, args are passed in their own types.  */
12053               DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
12054               if (PROMOTE_PROTOTYPES
12055                   && (TREE_CODE (type) == INTEGER_TYPE
12056                       || TREE_CODE (type) == ENUMERAL_TYPE)
12057                   && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
12058                 DECL_ARG_TYPE (decl) = integer_type_node;
12059               if (!any_error && init)
12060                 {
12061                   any_init++;
12062                   init = check_default_argument (decl, init);
12063                 }
12064               else
12065                 init = NULL_TREE;
12066
12067               if (decls == NULL_TREE)
12068                 {
12069                   decls = decl;
12070                   last_decl = decls;
12071                 }
12072               else
12073                 {
12074                   TREE_CHAIN (last_decl) = decl;
12075                   last_decl = decl;
12076                 }
12077               list_node = tree_cons (init, type, NULL_TREE);
12078               if (result == NULL_TREE)
12079                 {
12080                   result = list_node;
12081                   last_result = result;
12082                 }
12083               else
12084                 {
12085                   TREE_CHAIN (last_result) = list_node;
12086                   last_result = list_node;
12087                 }
12088             }
12089           if (last_result)
12090             TREE_CHAIN (last_result) = NULL_TREE;
12091           /* If there are no parameters, and the function does not end
12092              with `...', then last_decl will be NULL_TREE.  */
12093           if (last_decl != NULL_TREE)
12094             TREE_CHAIN (last_decl) = NULL_TREE;
12095         }
12096     }
12097
12098   last_function_parms = decls;
12099
12100   return result;
12101 }
12102
12103 /* Called from the parser to update an element of TYPE_ARG_TYPES for some
12104    FUNCTION_TYPE with the newly parsed version of its default argument, which
12105    was previously digested as text.  See snarf_defarg et al in lex.c.  */
12106
12107 void
12108 replace_defarg (arg, init)
12109      tree arg, init;
12110 {
12111   if (! processing_template_decl
12112       && ! can_convert_arg (TREE_VALUE (arg), TREE_TYPE (init), init))
12113     cp_pedwarn ("invalid type `%T' for default argument to `%T'",
12114                 TREE_TYPE (init), TREE_VALUE (arg));
12115   TREE_PURPOSE (arg) = init;
12116 }
12117 \f
12118 /* D is a constructor or overloaded `operator='.  Returns non-zero if
12119    D's arguments allow it to be a copy constructor, or copy assignment
12120    operator.  */
12121
12122 int
12123 copy_args_p (d)
12124      tree d;
12125 {
12126   tree t;
12127
12128   if (!DECL_FUNCTION_MEMBER_P (d))
12129     return 0;
12130
12131   t = FUNCTION_ARG_CHAIN (d);
12132   if (DECL_CONSTRUCTOR_P (d) && DECL_HAS_IN_CHARGE_PARM_P (d))
12133     t = TREE_CHAIN (t);
12134   if (t && TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
12135       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t)))
12136           == DECL_CONTEXT (d))
12137       && (TREE_CHAIN (t) == NULL_TREE
12138           || TREE_CHAIN (t) == void_list_node
12139           || TREE_PURPOSE (TREE_CHAIN (t))))
12140     return 1;
12141   return 0;
12142 }
12143
12144 /* These memoizing functions keep track of special properties which
12145    a class may have.  `grok_ctor_properties' notices whether a class
12146    has a constructor of the form X(X&), and also complains
12147    if the class has a constructor of the form X(X).
12148    `grok_op_properties' takes notice of the various forms of
12149    operator= which are defined, as well as what sorts of type conversion
12150    may apply.  Both functions take a FUNCTION_DECL as an argument.  */
12151
12152 int
12153 grok_ctor_properties (ctype, decl)
12154      tree ctype, decl;
12155 {
12156   tree parmtypes = FUNCTION_ARG_CHAIN (decl);
12157   tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
12158
12159   /* When a type has virtual baseclasses, a magical first int argument is
12160      added to any ctor so we can tell if the class has been initialized
12161      yet.  This could screw things up in this function, so we deliberately
12162      ignore the leading int if we're in that situation.  */
12163   if (DECL_HAS_IN_CHARGE_PARM_P (decl))
12164     {
12165       my_friendly_assert (parmtypes
12166                           && TREE_VALUE (parmtypes) == integer_type_node,
12167                           980529);
12168       parmtypes = TREE_CHAIN (parmtypes);
12169       parmtype = TREE_VALUE (parmtypes);
12170     }
12171
12172   /* [class.copy]
12173
12174      A non-template constructor for class X is a copy constructor if
12175      its first parameter is of type X&, const X&, volatile X& or const
12176      volatile X&, and either there are no other parameters or else all
12177      other parameters have default arguments.  */
12178   if (TREE_CODE (parmtype) == REFERENCE_TYPE
12179       && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype
12180       && (TREE_CHAIN (parmtypes) == NULL_TREE
12181           || TREE_CHAIN (parmtypes) == void_list_node
12182           || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
12183       && !(DECL_TEMPLATE_INSTANTIATION (decl)
12184            && is_member_template (DECL_TI_TEMPLATE (decl))))
12185     {
12186       TYPE_HAS_INIT_REF (ctype) = 1;
12187       if (CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12188         TYPE_HAS_CONST_INIT_REF (ctype) = 1;
12189     }
12190   /* [class.copy]
12191
12192      A declaration of a constructor for a class X is ill-formed if its
12193      first parameter is of type (optionally cv-qualified) X and either
12194      there are no other parameters or else all other parameters have
12195      default arguments.
12196
12197      We *don't* complain about member template instantiations that
12198      have this form, though; they can occur as we try to decide what
12199      constructor to use during overload resolution.  Since overload
12200      resolution will never prefer such a constructor to the
12201      non-template copy constructor (which is either explicitly or
12202      implicitly defined), there's no need to worry about their
12203      existence.  Theoretically, they should never even be
12204      instantiated, but that's hard to forestall.  */
12205   else if (TYPE_MAIN_VARIANT (parmtype) == ctype
12206            && (TREE_CHAIN (parmtypes) == NULL_TREE
12207                || TREE_CHAIN (parmtypes) == void_list_node
12208                || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
12209            && !(DECL_TEMPLATE_INSTANTIATION (decl)
12210                 && is_member_template (DECL_TI_TEMPLATE (decl))))
12211     {
12212       cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
12213                 ctype, ctype);
12214       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
12215       return 0;
12216     }
12217   else if (TREE_CODE (parmtype) == VOID_TYPE
12218            || TREE_PURPOSE (parmtypes) != NULL_TREE)
12219     TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
12220
12221   return 1;
12222 }
12223
12224 /* An operator with this code is unary, but can also be binary.  */
12225
12226 static int
12227 ambi_op_p (code)
12228      enum tree_code code;
12229 {
12230   return (code == INDIRECT_REF
12231           || code == ADDR_EXPR
12232           || code == CONVERT_EXPR
12233           || code == NEGATE_EXPR
12234           || code == PREINCREMENT_EXPR
12235           || code == PREDECREMENT_EXPR);
12236 }
12237
12238 /* An operator with this name can only be unary.  */
12239
12240 static int
12241 unary_op_p (code)
12242      enum tree_code code;
12243 {
12244   return (code == TRUTH_NOT_EXPR
12245           || code == BIT_NOT_EXPR
12246           || code == COMPONENT_REF
12247           || code == TYPE_EXPR);
12248 }
12249
12250 /* Do a little sanity-checking on how they declared their operator.  */
12251
12252 void
12253 grok_op_properties (decl, virtualp, friendp)
12254      tree decl;
12255      int virtualp, friendp;
12256 {
12257   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
12258   tree argtype;
12259   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
12260   tree name = DECL_NAME (decl);
12261   enum tree_code operator_code;
12262   int arity;
12263
12264   /* Count the number of arguments.  */
12265   for (argtype = argtypes, arity = 0;
12266        argtype && argtype != void_list_node;
12267        argtype = TREE_CHAIN (argtype))
12268     ++arity;
12269
12270   if (current_class_type == NULL_TREE)
12271     friendp = 1;
12272
12273   if (DECL_CONV_FN_P (decl))
12274     operator_code = TYPE_EXPR;
12275   else
12276     do
12277       {
12278 #define DEF_OPERATOR(NAME, CODE, NEW_MANGLING, OLD_MANGING, ARITY, ASSN_P)  \
12279         if (ansi_opname (CODE) == name)                                     \
12280           {                                                                 \
12281             operator_code = CODE;                                           \
12282             break;                                                          \
12283           }                                                                 \
12284         else if (ansi_assopname (CODE) == name)                             \
12285           {                                                                 \
12286             operator_code = CODE;                                           \
12287             DECL_ASSIGNMENT_OPERATOR_P (decl) = 1;                          \
12288             break;                                                          \
12289           }
12290
12291 #include "operators.def"
12292 #undef DEF_OPERATOR
12293
12294         my_friendly_abort (20000527);
12295       }
12296     while (0);
12297   my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526);
12298   SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12299
12300   if (! friendp)
12301     {
12302       switch (operator_code)
12303         {
12304         case CALL_EXPR:
12305           TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
12306           break;
12307
12308         case ARRAY_REF:
12309           TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
12310           break;
12311
12312         case COMPONENT_REF:
12313         case MEMBER_REF:
12314           TYPE_OVERLOADS_ARROW (current_class_type) = 1;
12315           break;
12316
12317         case NEW_EXPR:
12318           TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
12319           break;
12320
12321         case DELETE_EXPR:
12322           TYPE_GETS_DELETE (current_class_type) |= 1;
12323           break;
12324
12325         case VEC_NEW_EXPR:
12326           TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
12327           break;
12328
12329         case VEC_DELETE_EXPR:
12330           TYPE_GETS_DELETE (current_class_type) |= 2;
12331           break;
12332
12333         default:
12334           break;
12335         }
12336     }
12337
12338   if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
12339     {
12340       /* When the compiler encounters the definition of A::operator new, it
12341          doesn't look at the class declaration to find out if it's static.  */
12342       if (methodp)
12343         revert_static_member_fn (decl);
12344
12345       /* Take care of function decl if we had syntax errors.  */
12346       if (argtypes == NULL_TREE)
12347         TREE_TYPE (decl)
12348           = build_function_type (ptr_type_node,
12349                                  hash_tree_chain (integer_type_node,
12350                                                   void_list_node));
12351       else
12352         TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12353     }
12354   else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
12355     {
12356       if (methodp)
12357         revert_static_member_fn (decl);
12358
12359       if (argtypes == NULL_TREE)
12360         TREE_TYPE (decl)
12361           = build_function_type (void_type_node,
12362                                  hash_tree_chain (ptr_type_node,
12363                                                   void_list_node));
12364       else
12365         TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12366     }
12367   else
12368     {
12369       /* An operator function must either be a non-static member function
12370          or have at least one parameter of a class, a reference to a class,
12371          an enumeration, or a reference to an enumeration.  13.4.0.6 */
12372       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12373         {
12374           if (operator_code == TYPE_EXPR
12375               || operator_code == CALL_EXPR
12376               || operator_code == COMPONENT_REF
12377               || operator_code == ARRAY_REF
12378               || operator_code == NOP_EXPR)
12379             cp_error ("`%D' must be a nonstatic member function", decl);
12380           else
12381             {
12382               tree p = argtypes;
12383
12384               if (DECL_STATIC_FUNCTION_P (decl))
12385                 cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
12386
12387               if (p)
12388                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12389                   {
12390                     tree arg = TREE_VALUE (p);
12391                     if (TREE_CODE (arg) == REFERENCE_TYPE)
12392                       arg = TREE_TYPE (arg);
12393
12394                     /* This lets bad template code slip through.  */
12395                     if (IS_AGGR_TYPE (arg)
12396                         || TREE_CODE (arg) == ENUMERAL_TYPE
12397                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12398                         || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
12399                       goto foundaggr;
12400                   }
12401               cp_error
12402                 ("`%D' must have an argument of class or enumerated type",
12403                  decl);
12404             foundaggr:
12405               ;
12406             }
12407         }
12408
12409       if (operator_code == CALL_EXPR)
12410         return;                 /* No restrictions on args. */
12411
12412       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12413         {
12414           tree t = TREE_TYPE (name);
12415           if (! friendp)
12416             {
12417               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12418               const char *what = 0;
12419
12420               if (ref)
12421                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12422
12423               if (TREE_CODE (t) == VOID_TYPE)
12424                 what = "void";
12425               else if (t == current_class_type)
12426                 what = "the same type";
12427               /* Don't force t to be complete here.  */
12428               else if (IS_AGGR_TYPE (t)
12429                        && COMPLETE_TYPE_P (t)
12430                        && DERIVED_FROM_P (t, current_class_type))
12431                 what = "a base class";
12432
12433               if (what)
12434                 warning ("conversion to %s%s will never use a type conversion operator",
12435                          ref ? "a reference to " : "", what);
12436             }
12437         }
12438
12439       if (DECL_ASSIGNMENT_OPERATOR_P (decl)
12440           && operator_code == NOP_EXPR)
12441         {
12442           tree parmtype;
12443
12444           if (arity != 2 && methodp)
12445             {
12446               cp_error ("`%D' must take exactly one argument", decl);
12447               return;
12448             }
12449           parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
12450
12451           /* [class.copy]
12452
12453              A user-declared copy assignment operator X::operator= is
12454              a non-static non-template member function of class X with
12455              exactly one parameter of type X, X&, const X&, volatile
12456              X& or const volatile X&.  */
12457           if (copy_assignment_arg_p (parmtype, virtualp)
12458               && !(DECL_TEMPLATE_INSTANTIATION (decl)
12459                    && is_member_template (DECL_TI_TEMPLATE (decl)))
12460               && ! friendp)
12461             {
12462               TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
12463               if (TREE_CODE (parmtype) != REFERENCE_TYPE
12464                   || CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12465                 TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
12466             }
12467         }
12468       else if (operator_code == COND_EXPR)
12469         {
12470           /* 13.4.0.3 */
12471           cp_error ("ISO C++ prohibits overloading operator ?:");
12472         }
12473       else if (ambi_op_p (operator_code))
12474         {
12475           if (arity == 1)
12476             /* We pick the one-argument operator codes by default, so
12477                we don't have to change anything.  */
12478             ;
12479           else if (arity == 2)
12480             {
12481               /* If we thought this was a unary operator, we now know
12482                  it to be a binary operator.  */
12483               switch (operator_code)
12484                 {
12485                 case INDIRECT_REF:
12486                   operator_code = MULT_EXPR;
12487                   break;
12488
12489                 case ADDR_EXPR:
12490                   operator_code = BIT_AND_EXPR;
12491                   break;
12492
12493                 case CONVERT_EXPR:
12494                   operator_code = PLUS_EXPR;
12495                   break;
12496
12497                 case NEGATE_EXPR:
12498                   operator_code = MINUS_EXPR;
12499                   break;
12500
12501                 case PREINCREMENT_EXPR:
12502                   operator_code = POSTINCREMENT_EXPR;
12503                   break;
12504
12505                 case PREDECREMENT_EXPR:
12506                   operator_code = POSTDECREMENT_EXPR;
12507                   break;
12508
12509                 default:
12510                   my_friendly_abort (20000527);
12511                 }
12512
12513               SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12514
12515               if ((operator_code == POSTINCREMENT_EXPR
12516                    || operator_code == POSTDECREMENT_EXPR)
12517                   && ! processing_template_decl
12518                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12519                 {
12520                   if (methodp)
12521                     cp_error ("postfix `%D' must take `int' as its argument",
12522                               decl);
12523                   else
12524                     cp_error
12525                       ("postfix `%D' must take `int' as its second argument",
12526                        decl);
12527                 }
12528             }
12529           else
12530             {
12531               if (methodp)
12532                 cp_error ("`%D' must take either zero or one argument", decl);
12533               else
12534                 cp_error ("`%D' must take either one or two arguments", decl);
12535             }
12536
12537           /* More Effective C++ rule 6.  */
12538           if (warn_ecpp
12539               && (operator_code == POSTINCREMENT_EXPR
12540                   || operator_code == POSTDECREMENT_EXPR
12541                   || operator_code == PREINCREMENT_EXPR
12542                   || operator_code == PREDECREMENT_EXPR))
12543             {
12544               tree arg = TREE_VALUE (argtypes);
12545               tree ret = TREE_TYPE (TREE_TYPE (decl));
12546               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12547                 arg = TREE_TYPE (arg);
12548               arg = TYPE_MAIN_VARIANT (arg);
12549               if (operator_code == PREINCREMENT_EXPR
12550                   || operator_code == PREDECREMENT_EXPR)
12551                 {
12552                   if (TREE_CODE (ret) != REFERENCE_TYPE
12553                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12554                                        arg))
12555                     cp_warning ("prefix `%D' should return `%T'", decl,
12556                                 build_reference_type (arg));
12557                 }
12558               else
12559                 {
12560                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12561                     cp_warning ("postfix `%D' should return `%T'", decl, arg);
12562                 }
12563             }
12564         }
12565       else if (unary_op_p (operator_code))
12566         {
12567           if (arity != 1)
12568             {
12569               if (methodp)
12570                 cp_error ("`%D' must take `void'", decl);
12571               else
12572                 cp_error ("`%D' must take exactly one argument", decl);
12573             }
12574         }
12575       else /* if (binary_op_p (operator_code)) */
12576         {
12577           if (arity != 2)
12578             {
12579               if (methodp)
12580                 cp_error ("`%D' must take exactly one argument", decl);
12581               else
12582                 cp_error ("`%D' must take exactly two arguments", decl);
12583             }
12584
12585           /* More Effective C++ rule 7.  */
12586           if (warn_ecpp
12587               && (operator_code == TRUTH_ANDIF_EXPR
12588                   || operator_code == TRUTH_ORIF_EXPR
12589                   || operator_code == COMPOUND_EXPR))
12590             cp_warning ("user-defined `%D' always evaluates both arguments",
12591                         decl);
12592         }
12593
12594       /* Effective C++ rule 23.  */
12595       if (warn_ecpp
12596           && arity == 2
12597           && (operator_code == PLUS_EXPR
12598               || operator_code == MINUS_EXPR
12599               || operator_code == TRUNC_DIV_EXPR
12600               || operator_code == MULT_EXPR)
12601           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12602         cp_warning ("`%D' should return by value", decl);
12603
12604       /* 13.4.0.8 */
12605       for (; argtypes && argtypes != void_list_node;
12606           argtypes = TREE_CHAIN (argtypes))
12607         if (TREE_PURPOSE (argtypes))
12608           {
12609             TREE_PURPOSE (argtypes) = NULL_TREE;
12610             if (operator_code == POSTINCREMENT_EXPR
12611                 || operator_code == POSTDECREMENT_EXPR)
12612               {
12613                 if (pedantic)
12614                   cp_pedwarn ("`%D' cannot have default arguments", decl);
12615               }
12616             else
12617               cp_error ("`%D' cannot have default arguments", decl);
12618           }
12619
12620     }
12621 }
12622 \f
12623 static const char *
12624 tag_name (code)
12625      enum tag_types code;
12626 {
12627   switch (code)
12628     {
12629     case record_type:
12630       return "struct";
12631     case class_type:
12632       return "class";
12633     case union_type:
12634       return "union ";
12635     case enum_type:
12636       return "enum";
12637     default:
12638       my_friendly_abort (981122);
12639     }
12640 }
12641
12642 /* Get the struct, enum or union (CODE says which) with tag NAME.
12643    Define the tag as a forward-reference if it is not defined.
12644
12645    C++: If a class derivation is given, process it here, and report
12646    an error if multiple derivation declarations are not identical.
12647
12648    If this is a definition, come in through xref_tag and only look in
12649    the current frame for the name (since C++ allows new names in any
12650    scope.)  */
12651
12652 tree
12653 xref_tag (code_type_node, name, globalize)
12654      tree code_type_node;
12655      tree name;
12656      int globalize;
12657 {
12658   enum tag_types tag_code;
12659   enum tree_code code;
12660   register tree ref, t;
12661   struct binding_level *b = current_binding_level;
12662   int got_type = 0;
12663   tree attributes = NULL_TREE;
12664   tree context = NULL_TREE;
12665
12666   /* If we are called from the parser, code_type_node will sometimes be a
12667      TREE_LIST.  This indicates that the user wrote
12668      "class __attribute__ ((foo)) bar".  Extract the attributes so we can
12669      use them later.  */
12670   if (TREE_CODE (code_type_node) == TREE_LIST)
12671     {
12672       attributes = TREE_PURPOSE (code_type_node);
12673       code_type_node = TREE_VALUE (code_type_node);
12674     }
12675
12676   tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12677   switch (tag_code)
12678     {
12679     case record_type:
12680     case class_type:
12681       code = RECORD_TYPE;
12682       break;
12683     case union_type:
12684       code = UNION_TYPE;
12685       break;
12686     case enum_type:
12687       code = ENUMERAL_TYPE;
12688       break;
12689     default:
12690       my_friendly_abort (18);
12691     }
12692
12693   /* If a cross reference is requested, look up the type
12694      already defined for this tag and return it.  */
12695   if (TYPE_P (name))
12696     {
12697       t = name;
12698       name = TYPE_IDENTIFIER (t);
12699       got_type = 1;
12700     }
12701   else
12702     t = IDENTIFIER_TYPE_VALUE (name);
12703
12704   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12705       && TREE_CODE (t) != TEMPLATE_TEMPLATE_PARM)
12706     t = NULL_TREE;
12707
12708   if (! globalize)
12709     {
12710       /* If we know we are defining this tag, only look it up in
12711          this scope and don't try to find it as a type.  */
12712       ref = lookup_tag (code, name, b, 1);
12713     }
12714   else
12715     {
12716       if (t)
12717         {
12718           /* [dcl.type.elab] If the identifier resolves to a
12719              typedef-name or a template type-parameter, the
12720              elaborated-type-specifier is ill-formed.  */
12721           if (t != TYPE_MAIN_VARIANT (t)
12722               || (CLASS_TYPE_P (t) && TYPE_WAS_ANONYMOUS (t)))
12723             cp_pedwarn ("using typedef-name `%D' after `%s'",
12724                         TYPE_NAME (t), tag_name (tag_code));
12725           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12726             cp_error ("using template type parameter `%T' after `%s'",
12727                       t, tag_name (tag_code));
12728
12729           ref = t;
12730         }
12731       else
12732         ref = lookup_tag (code, name, b, 0);
12733
12734       if (! ref)
12735         {
12736           /* Try finding it as a type declaration.  If that wins,
12737              use it.  */
12738           ref = lookup_name (name, 1);
12739
12740           if (ref != NULL_TREE
12741               && processing_template_decl
12742               && DECL_CLASS_TEMPLATE_P (ref)
12743               && template_class_depth (current_class_type) == 0)
12744             /* Since GLOBALIZE is true, we're declaring a global
12745                template, so we want this type.  */
12746             ref = DECL_TEMPLATE_RESULT (ref);
12747
12748           if (ref && TREE_CODE (ref) == TYPE_DECL
12749               && TREE_CODE (TREE_TYPE (ref)) == code)
12750             ref = TREE_TYPE (ref);
12751           else
12752             ref = NULL_TREE;
12753         }
12754
12755       if (ref && current_class_type
12756           && template_class_depth (current_class_type)
12757           && PROCESSING_REAL_TEMPLATE_DECL_P ())
12758         {
12759           /* Since GLOBALIZE is non-zero, we are not looking at a
12760              definition of this tag.  Since, in addition, we are currently
12761              processing a (member) template declaration of a template
12762              class, we must be very careful; consider:
12763
12764                template <class X>
12765                struct S1
12766
12767                template <class U>
12768                struct S2
12769                { template <class V>
12770                friend struct S1; };
12771
12772              Here, the S2::S1 declaration should not be confused with the
12773              outer declaration.  In particular, the inner version should
12774              have a template parameter of level 2, not level 1.  This
12775              would be particularly important if the member declaration
12776              were instead:
12777
12778                template <class V = U> friend struct S1;
12779
12780              say, when we should tsubst into `U' when instantiating
12781              S2.  On the other hand, when presented with:
12782
12783                  template <class T>
12784                  struct S1 {
12785                    template <class U>
12786                    struct S2 {};
12787                    template <class U>
12788                    friend struct S2;
12789                  };
12790
12791               we must find the inner binding eventually.  We
12792               accomplish this by making sure that the new type we
12793               create to represent this declaration has the right
12794               TYPE_CONTEXT.  */
12795           context = TYPE_CONTEXT (ref);
12796           ref = NULL_TREE;
12797         }
12798     }
12799
12800   if (! ref)
12801     {
12802       /* If no such tag is yet defined, create a forward-reference node
12803          and record it as the "definition".
12804          When a real declaration of this type is found,
12805          the forward-reference will be altered into a real type.  */
12806       if (code == ENUMERAL_TYPE)
12807         {
12808           cp_error ("use of enum `%#D' without previous declaration", name);
12809
12810           ref = make_node (ENUMERAL_TYPE);
12811
12812           /* Give the type a default layout like unsigned int
12813              to avoid crashing if it does not get defined.  */
12814           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12815           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12816           TYPE_USER_ALIGN (ref) = 0;
12817           TREE_UNSIGNED (ref) = 1;
12818           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12819           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12820           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12821
12822           /* Enable us to recognize when a type is created in class context.
12823              To do nested classes correctly, this should probably be cleared
12824              out when we leave this classes scope.  Currently this in only
12825              done in `start_enum'.  */
12826
12827           pushtag (name, ref, globalize);
12828         }
12829       else
12830         {
12831           struct binding_level *old_b = class_binding_level;
12832
12833           ref = make_aggr_type (code);
12834           TYPE_CONTEXT (ref) = context;
12835
12836 #ifdef NONNESTED_CLASSES
12837           /* Class types don't nest the way enums do.  */
12838           class_binding_level = (struct binding_level *)0;
12839 #endif
12840           pushtag (name, ref, globalize);
12841           class_binding_level = old_b;
12842         }
12843     }
12844   else
12845     {
12846       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12847         redeclare_class_template (ref, current_template_parms);
12848     }
12849
12850   /* Until the type is defined, tentatively accept whatever
12851      structure tag the user hands us.  */
12852   if (!COMPLETE_TYPE_P (ref)
12853       && ref != current_class_type
12854       /* Have to check this, in case we have contradictory tag info.  */
12855       && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
12856     {
12857       if (tag_code == class_type)
12858         CLASSTYPE_DECLARED_CLASS (ref) = 1;
12859       else if (tag_code == record_type)
12860         CLASSTYPE_DECLARED_CLASS (ref) = 0;
12861     }
12862
12863   TREE_TYPE (ref) = attributes;
12864
12865   return ref;
12866 }
12867
12868 tree
12869 xref_tag_from_type (old, id, globalize)
12870      tree old, id;
12871      int globalize;
12872 {
12873   tree code_type_node;
12874
12875   if (TREE_CODE (old) == RECORD_TYPE)
12876     code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
12877                       ? class_type_node : record_type_node);
12878   else
12879     code_type_node = union_type_node;
12880
12881   if (id == NULL_TREE)
12882     id = TYPE_IDENTIFIER (old);
12883
12884   return xref_tag (code_type_node, id, globalize);
12885 }
12886
12887 /* REF is a type (named NAME), for which we have just seen some
12888    baseclasses.  BINFO is a list of those baseclasses; the
12889    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12890    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
12891    struct, or union.  */
12892
12893 void
12894 xref_basetypes (code_type_node, name, ref, binfo)
12895      tree code_type_node;
12896      tree name, ref;
12897      tree binfo;
12898 {
12899   /* In the declaration `A : X, Y, ... Z' we mark all the types
12900      (A, X, Y, ..., Z) so we can check for duplicates.  */
12901   tree binfos;
12902   tree base;
12903
12904   int i, len;
12905   enum tag_types tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12906
12907   if (tag_code == union_type)
12908     {
12909       cp_error ("derived union `%T' invalid", ref);
12910       return;
12911     }
12912
12913   len = list_length (binfo);
12914
12915   /* First, make sure that any templates in base-classes are
12916      instantiated.  This ensures that if we call ourselves recursively
12917      we do not get confused about which classes are marked and which
12918      are not.  */
12919   for (base = binfo; base; base = TREE_CHAIN (base))
12920     complete_type (TREE_VALUE (base));
12921
12922   SET_CLASSTYPE_MARKED (ref);
12923   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
12924
12925   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
12926     {
12927       /* The base of a derived struct is public by default.  */
12928       int via_public
12929         = (TREE_PURPOSE (binfo) == access_public_node
12930            || TREE_PURPOSE (binfo) == access_public_virtual_node
12931            || (tag_code != class_type
12932                && (TREE_PURPOSE (binfo) == access_default_node
12933                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
12934       int via_protected
12935         = (TREE_PURPOSE (binfo) == access_protected_node
12936            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
12937       int via_virtual
12938         = (TREE_PURPOSE (binfo) == access_private_virtual_node
12939            || TREE_PURPOSE (binfo) == access_protected_virtual_node
12940            || TREE_PURPOSE (binfo) == access_public_virtual_node
12941            || TREE_PURPOSE (binfo) == access_default_virtual_node);
12942       tree basetype = TREE_VALUE (binfo);
12943       tree base_binfo;
12944
12945       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
12946         basetype = TREE_TYPE (basetype);
12947       if (!basetype
12948           || (TREE_CODE (basetype) != RECORD_TYPE
12949               && TREE_CODE (basetype) != TYPENAME_TYPE
12950               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
12951               && TREE_CODE (basetype) != TEMPLATE_TEMPLATE_PARM))
12952         {
12953           cp_error ("base type `%T' fails to be a struct or class type",
12954                     TREE_VALUE (binfo));
12955           continue;
12956         }
12957
12958       GNU_xref_hier (name, basetype, via_public, via_virtual, 0);
12959
12960       /* This code replaces similar code in layout_basetypes.
12961          We put the complete_type first for implicit `typename'.  */
12962       if (!COMPLETE_TYPE_P (basetype)
12963           && ! (current_template_parms && uses_template_parms (basetype)))
12964         {
12965           cp_error ("base class `%T' has incomplete type", basetype);
12966           continue;
12967         }
12968       else
12969         {
12970           if (CLASSTYPE_MARKED (basetype))
12971             {
12972               if (basetype == ref)
12973                 cp_error ("recursive type `%T' undefined", basetype);
12974               else
12975                 cp_error ("duplicate base type `%T' invalid", basetype);
12976               continue;
12977             }
12978
12979           if (TYPE_FOR_JAVA (basetype)
12980               && (current_lang_stack
12981                   == &VARRAY_TREE (current_lang_base, 0)))
12982             TYPE_FOR_JAVA (ref) = 1;
12983
12984           /* Note that the BINFO records which describe individual
12985              inheritances are *not* shared in the lattice!  They
12986              cannot be shared because a given baseclass may be
12987              inherited with different `accessibility' by different
12988              derived classes.  (Each BINFO record describing an
12989              individual inheritance contains flags which say what
12990              the `accessibility' of that particular inheritance is.)  */
12991
12992           base_binfo
12993             = make_binfo (size_zero_node, basetype,
12994                           CLASS_TYPE_P (basetype)
12995                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
12996                           CLASS_TYPE_P (basetype)
12997                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
12998
12999           TREE_VEC_ELT (binfos, i) = base_binfo;
13000           TREE_VIA_PUBLIC (base_binfo) = via_public;
13001           TREE_VIA_PROTECTED (base_binfo) = via_protected;
13002           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
13003           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
13004
13005           /* We need to unshare the binfos now so that lookups during class
13006              definition work.  */
13007           unshare_base_binfos (base_binfo);
13008
13009           SET_CLASSTYPE_MARKED (basetype);
13010
13011           /* We are free to modify these bits because they are meaningless
13012              at top level, and BASETYPE is a top-level type.  */
13013           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
13014             {
13015               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
13016               /* Converting to a virtual base class requires looking
13017                  up the offset of the virtual base.  */
13018               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13019             }
13020
13021           if (CLASS_TYPE_P (basetype))
13022             {
13023               TYPE_HAS_NEW_OPERATOR (ref)
13024                 |= TYPE_HAS_NEW_OPERATOR (basetype);
13025               TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
13026                 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
13027               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
13028               /* If the base-class uses multiple inheritance, so do we.  */
13029               TYPE_USES_MULTIPLE_INHERITANCE (ref)
13030                 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
13031               /* Likewise, if converting to a base of the base may require
13032                  code, then we may need to generate code to convert to a
13033                  base as well.  */
13034               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
13035                 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
13036             }
13037
13038           i += 1;
13039         }
13040     }
13041   if (i)
13042     TREE_VEC_LENGTH (binfos) = i;
13043   else
13044     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
13045
13046   if (i > 1)
13047     {
13048       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
13049       /* If there is more than one non-empty they cannot be at the same
13050          address.  */
13051       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13052     }
13053
13054   /* Unmark all the types.  */
13055   while (--i >= 0)
13056     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
13057   CLEAR_CLASSTYPE_MARKED (ref);
13058
13059   /* Now that we know all the base-classes, set up the list of virtual
13060      bases.  */
13061   get_vbase_types (ref);
13062 }
13063
13064 \f
13065 /* Begin compiling the definition of an enumeration type.
13066    NAME is its name (or null if anonymous).
13067    Returns the type object, as yet incomplete.
13068    Also records info about it so that build_enumerator
13069    may be used to declare the individual values as they are read.  */
13070
13071 tree
13072 start_enum (name)
13073      tree name;
13074 {
13075   register tree enumtype = NULL_TREE;
13076   struct binding_level *b = current_binding_level;
13077
13078   /* If this is the real definition for a previous forward reference,
13079      fill in the contents in the same object that used to be the
13080      forward reference.  */
13081
13082   if (name != NULL_TREE)
13083     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
13084
13085   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
13086     {
13087       cp_error ("multiple definition of `%#T'", enumtype);
13088       cp_error_at ("previous definition here", enumtype);
13089       /* Clear out TYPE_VALUES, and start again.  */
13090       TYPE_VALUES (enumtype) = NULL_TREE;
13091     }
13092   else
13093     {
13094       enumtype = make_node (ENUMERAL_TYPE);
13095       pushtag (name, enumtype, 0);
13096     }
13097
13098   if (current_class_type)
13099     TREE_ADDRESSABLE (b->tags) = 1;
13100
13101   GNU_xref_decl (current_function_decl, enumtype);
13102   return enumtype;
13103 }
13104
13105 /* After processing and defining all the values of an enumeration type,
13106    install their decls in the enumeration type and finish it off.
13107    ENUMTYPE is the type object and VALUES a list of name-value pairs.
13108    Returns ENUMTYPE.  */
13109
13110 tree
13111 finish_enum (enumtype)
13112      tree enumtype;
13113 {
13114   register tree minnode = NULL_TREE, maxnode = NULL_TREE;
13115   /* Calculate the maximum value of any enumerator in this type.  */
13116
13117   tree values = TYPE_VALUES (enumtype);
13118   if (values)
13119     {
13120       tree pair;
13121
13122       for (pair = values; pair; pair = TREE_CHAIN (pair))
13123         {
13124           tree decl;
13125           tree value;
13126
13127           /* The TREE_VALUE is a CONST_DECL for this enumeration
13128              constant.  */
13129           decl = TREE_VALUE (pair);
13130
13131           /* [dcl.enum]
13132
13133              Following the closing brace of an enum-specifier, each
13134              enumerator has the type of its enumeration.  Prior to the
13135              closing brace, the type of each enumerator is the type of
13136              its initializing value.  */
13137           TREE_TYPE (decl) = enumtype;
13138
13139           /* The DECL_INITIAL will be NULL if we are processing a
13140              template declaration and this enumeration constant had no
13141              explicit initializer.  */
13142           value = DECL_INITIAL (decl);
13143           if (value && !processing_template_decl)
13144             {
13145               /* Set the TREE_TYPE for the VALUE as well.  That's so
13146                  that when we call decl_constant_value we get an
13147                  entity of the right type (but with the constant
13148                  value).  Since we shouldn't ever call
13149                  decl_constant_value on a template type, there's no
13150                  reason to do that when processing_template_decl.
13151                  And, if the expression is something like a
13152                  TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will
13153                  wreak havoc on the intended type of the expression.
13154
13155                  Of course, there's also no point in trying to compute
13156                  minimum or maximum values if we're in a template.  */
13157               TREE_TYPE (value) = enumtype;
13158
13159               if (!minnode)
13160                 minnode = maxnode = value;
13161               else if (tree_int_cst_lt (maxnode, value))
13162                 maxnode = value;
13163               else if (tree_int_cst_lt (value, minnode))
13164                 minnode = value;
13165             }
13166
13167           if (processing_template_decl)
13168             /* If this is just a template, leave the CONST_DECL
13169                alone.  That way tsubst_copy will find CONST_DECLs for
13170                CONST_DECLs, and not INTEGER_CSTs.  */
13171             ;
13172           else
13173             /* In the list we're building up, we want the enumeration
13174                values, not the CONST_DECLs.  */
13175             TREE_VALUE (pair) = value;
13176         }
13177     }
13178   else
13179     maxnode = minnode = integer_zero_node;
13180
13181   TYPE_VALUES (enumtype) = nreverse (values);
13182
13183   if (processing_template_decl)
13184     {
13185       tree scope = current_scope ();
13186       if (scope && TREE_CODE (scope) == FUNCTION_DECL)
13187         add_tree (build_min (TAG_DEFN, enumtype));
13188     }
13189   else
13190     {
13191       int unsignedp = tree_int_cst_sgn (minnode) >= 0;
13192       int lowprec = min_precision (minnode, unsignedp);
13193       int highprec = min_precision (maxnode, unsignedp);
13194       int precision = MAX (lowprec, highprec);
13195       tree tem;
13196
13197       TYPE_SIZE (enumtype) = NULL_TREE;
13198
13199       /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
13200
13201       TYPE_PRECISION (enumtype) = precision;
13202       if (unsignedp)
13203         fixup_unsigned_type (enumtype);
13204       else
13205         fixup_signed_type (enumtype);
13206
13207       if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
13208         /* Use the width of the narrowest normal C type which is wide
13209            enough.  */
13210         TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
13211                                                     (precision, 1));
13212       else
13213         TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
13214
13215       TYPE_SIZE (enumtype) = 0;
13216       layout_type (enumtype);
13217
13218       /* Fix up all variant types of this enum type.  */
13219       for (tem = TYPE_MAIN_VARIANT (enumtype); tem;
13220            tem = TYPE_NEXT_VARIANT (tem))
13221         {
13222           TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
13223           TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
13224           TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
13225           TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
13226           TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
13227           TYPE_MODE (tem) = TYPE_MODE (enumtype);
13228           TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
13229           TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
13230           TYPE_USER_ALIGN (tem) = TYPE_USER_ALIGN (enumtype);
13231           TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
13232         }
13233
13234       /* Finish debugging output for this type.  */
13235       rest_of_type_compilation (enumtype, namespace_bindings_p ());
13236     }
13237
13238   return enumtype;
13239 }
13240
13241 /* Build and install a CONST_DECL for an enumeration constant of the
13242    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13243    Assignment of sequential values by default is handled here.  */
13244
13245 void
13246 build_enumerator (name, value, enumtype)
13247      tree name;
13248      tree value;
13249      tree enumtype;
13250 {
13251   tree decl;
13252   tree context;
13253   tree type;
13254   tree values;
13255
13256   /* Remove no-op casts from the value.  */
13257   if (value)
13258     STRIP_TYPE_NOPS (value);
13259
13260   if (! processing_template_decl)
13261     {
13262       /* Validate and default VALUE.  */
13263       if (value != NULL_TREE)
13264         {
13265           value = decl_constant_value (value);
13266
13267           if (TREE_CODE (value) == INTEGER_CST)
13268             {
13269               value = default_conversion (value);
13270               constant_expression_warning (value);
13271             }
13272           else
13273             {
13274               cp_error ("enumerator value for `%D' not integer constant", name);
13275               value = NULL_TREE;
13276             }
13277         }
13278
13279       /* Default based on previous value.  */
13280       if (value == NULL_TREE && ! processing_template_decl)
13281         {
13282           tree prev_value;
13283
13284           if (TYPE_VALUES (enumtype))
13285             {
13286               /* The next value is the previous value ... */
13287               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
13288               /* ... plus one.  */
13289               value = cp_build_binary_op (PLUS_EXPR,
13290                                           prev_value,
13291                                           integer_one_node);
13292
13293               if (tree_int_cst_lt (value, prev_value))
13294                 cp_error ("overflow in enumeration values at `%D'", name);
13295             }
13296           else
13297             value = integer_zero_node;
13298         }
13299
13300       /* Remove no-op casts from the value.  */
13301       if (value)
13302         STRIP_TYPE_NOPS (value);
13303 #if 0
13304       /* To fix MAX_VAL enum consts. (bkoz)  */
13305       TREE_TYPE (value) = integer_type_node;
13306 #endif
13307     }
13308
13309   /* We always have to copy here; not all INTEGER_CSTs are unshared.
13310      Even in other cases, we will later (in finish_enum) be setting
13311      the type of VALUE.  But, we don't need to make a copy if this
13312      VALUE is one of the enumeration constants for this same
13313      enumeration type.  */
13314   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
13315     if (TREE_VALUE (values) == value)
13316       break;
13317   /* If we didn't break out of the loop, then we do need a copy.  */
13318   if (!values && value)
13319     value = copy_node (value);
13320
13321   /* C++ associates enums with global, function, or class declarations.  */
13322   context = current_scope ();
13323
13324   /* Build the actual enumeration constant.  Note that the enumeration
13325     constants have the type of their initializers until the
13326     enumeration is complete:
13327
13328       [ dcl.enum ]
13329
13330       Following the closing brace of an enum-specifier, each enumer-
13331       ator has the type of its enumeration.  Prior to the closing
13332       brace, the type of each enumerator is the type of its
13333       initializing value.
13334
13335     In finish_enum we will reset the type.  Of course, if we're
13336     processing a template, there may be no value.   */
13337   type = value ? TREE_TYPE (value) : NULL_TREE;
13338
13339   if (context && context == current_class_type)
13340     /* This enum declaration is local to the class.  We need the full
13341       lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
13342     decl = build_lang_decl (CONST_DECL, name, type);
13343   else
13344     /* It's a global enum, or it's local to a function.  (Note local to
13345       a function could mean local to a class method.  */
13346     decl = build_decl (CONST_DECL, name, type);
13347
13348   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
13349   DECL_INITIAL (decl) = value;
13350   TREE_READONLY (decl) = 1;
13351
13352   if (context && context == current_class_type)
13353     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13354       on the TYPE_FIELDS list for `S'.  (That's so that you can say
13355       things like `S::i' later.)  */
13356     finish_member_declaration (decl);
13357   else
13358     {
13359       pushdecl (decl);
13360       GNU_xref_decl (current_function_decl, decl);
13361     }
13362
13363   /* Add this enumeration constant to the list for this type.  */
13364   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13365 }
13366
13367 \f
13368 static int function_depth;
13369
13370 /* We're defining DECL.  Make sure that it's type is OK.  */
13371
13372 static void
13373 check_function_type (decl)
13374      tree decl;
13375 {
13376   tree fntype = TREE_TYPE (decl);
13377   tree return_type = complete_type (TREE_TYPE (fntype));
13378
13379   /* In a function definition, arg types must be complete.  */
13380   require_complete_types_for_parms (current_function_parms);
13381
13382   if (!COMPLETE_OR_VOID_TYPE_P (return_type))
13383     {
13384       cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
13385
13386       /* Make it return void instead, but don't change the
13387          type of the DECL_RESULT, in case we have a named return value.  */
13388       if (TREE_CODE (fntype) == METHOD_TYPE)
13389         {
13390           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
13391           TREE_TYPE (decl)
13392             = build_cplus_method_type (ctype,
13393                                        void_type_node,
13394                                        FUNCTION_ARG_CHAIN (decl));
13395         }
13396       else
13397         TREE_TYPE (decl)
13398           = build_function_type (void_type_node,
13399                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
13400       TREE_TYPE (decl)
13401         = build_exception_variant (fntype,
13402                                    TYPE_RAISES_EXCEPTIONS (fntype));
13403     }
13404   else
13405     abstract_virtuals_error (decl, TREE_TYPE (fntype));
13406 }
13407
13408 /* Create the FUNCTION_DECL for a function definition.
13409    DECLSPECS and DECLARATOR are the parts of the declaration;
13410    they describe the function's name and the type it returns,
13411    but twisted together in a fashion that parallels the syntax of C.
13412
13413    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13414    DECLARATOR is really the DECL for the function we are about to
13415    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13416    indicating that the function is an inline defined in-class, and
13417    SF_EXPAND indicating that we should generate RTL for this
13418    function.
13419
13420    This function creates a binding context for the function body
13421    as well as setting up the FUNCTION_DECL in current_function_decl.
13422
13423    Returns 1 on success.  If the DECLARATOR is not suitable for a function
13424    (it defines a datum instead), we return 0, which tells
13425    yyparse to report a parse error.
13426
13427    For C++, we must first check whether that datum makes any sense.
13428    For example, "class A local_a(1,2);" means that variable local_a
13429    is an aggregate of type A, which should have a constructor
13430    applied to it with the argument list [1, 2].  */
13431
13432 int
13433 start_function (declspecs, declarator, attrs, flags)
13434      tree declspecs, declarator, attrs;
13435      int flags;
13436 {
13437   tree decl1;
13438   tree ctype = NULL_TREE;
13439   tree fntype;
13440   tree restype;
13441   extern int have_extern_spec;
13442   extern int used_extern_spec;
13443   int doing_friend = 0;
13444   struct binding_level *bl;
13445
13446   /* Sanity check.  */
13447   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
13448   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
13449
13450   /* This should only be done once on the top most decl.  */
13451   if (have_extern_spec && !used_extern_spec)
13452     {
13453       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
13454       used_extern_spec = 1;
13455     }
13456
13457   if (flags & SF_PRE_PARSED)
13458     {
13459       decl1 = declarator;
13460
13461       fntype = TREE_TYPE (decl1);
13462       if (TREE_CODE (fntype) == METHOD_TYPE)
13463         ctype = TYPE_METHOD_BASETYPE (fntype);
13464
13465       /* ISO C++ 11.4/5.  A friend function defined in a class is in
13466          the (lexical) scope of the class in which it is defined.  */
13467       if (!ctype && DECL_FRIEND_P (decl1))
13468         {
13469           ctype = DECL_FRIEND_CONTEXT (decl1);
13470
13471           /* CTYPE could be null here if we're dealing with a template;
13472              for example, `inline friend float foo()' inside a template
13473              will have no CTYPE set.  */
13474           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13475             ctype = NULL_TREE;
13476           else
13477             doing_friend = 1;
13478         }
13479
13480       last_function_parms = DECL_ARGUMENTS (decl1);
13481       last_function_parm_tags = NULL_TREE;
13482     }
13483   else
13484     {
13485       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL_TREE);
13486       /* If the declarator is not suitable for a function definition,
13487          cause a syntax error.  */
13488       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
13489
13490       fntype = TREE_TYPE (decl1);
13491
13492       restype = TREE_TYPE (fntype);
13493       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13494         {
13495           cp_error ("semicolon missing after declaration of `%#T'", restype);
13496           shadow_tag (build_tree_list (NULL_TREE, restype));
13497           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13498           if (TREE_CODE (fntype) == FUNCTION_TYPE)
13499             fntype = build_function_type (integer_type_node,
13500                                           TYPE_ARG_TYPES (fntype));
13501           else
13502             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13503                                               integer_type_node,
13504                                               TYPE_ARG_TYPES (fntype));
13505           TREE_TYPE (decl1) = fntype;
13506         }
13507
13508       if (TREE_CODE (fntype) == METHOD_TYPE)
13509         ctype = TYPE_METHOD_BASETYPE (fntype);
13510       else if (DECL_MAIN_P (decl1))
13511         {
13512           /* If this doesn't return integer_type, complain.  */
13513           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13514             {
13515               if (pedantic || warn_return_type)
13516                 pedwarn ("return type for `main' changed to `int'");
13517               TREE_TYPE (decl1) = fntype = default_function_type;
13518             }
13519         }
13520     }
13521
13522   /* Sometimes we don't notice that a function is a static member, and
13523      build a METHOD_TYPE for it.  Fix that up now.  */
13524   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13525       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13526     {
13527       revert_static_member_fn (decl1);
13528       last_function_parms = TREE_CHAIN (last_function_parms);
13529       ctype = NULL_TREE;
13530     }
13531
13532   /* Warn if function was previously implicitly declared
13533      (but not if we warned then).  */
13534   if (! warn_implicit
13535       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13536     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13537
13538   /* Set up current_class_type, and enter the scope of the class, if
13539      appropriate.  */
13540   if (ctype)
13541     push_nested_class (ctype, 1);
13542   else if (DECL_STATIC_FUNCTION_P (decl1))
13543     push_nested_class (DECL_CONTEXT (decl1), 2);
13544
13545   /* Now that we have entered the scope of the class, we must restore
13546      the bindings for any template parameters surrounding DECL1, if it
13547      is an inline member template.  (Order is important; consider the
13548      case where a template parameter has the same name as a field of
13549      the class.)  It is not until after this point that
13550      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
13551   if (flags & SF_INCLASS_INLINE)
13552     maybe_begin_member_template_processing (decl1);
13553
13554   /* Effective C++ rule 15.  See also c_expand_return.  */
13555   if (warn_ecpp
13556       && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
13557       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13558     cp_warning ("`operator=' should return a reference to `*this'");
13559
13560   /* Make the init_value nonzero so pushdecl knows this is not tentative.
13561      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
13562   if (!DECL_INITIAL (decl1))
13563     DECL_INITIAL (decl1) = error_mark_node;
13564
13565 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
13566   SET_DEFAULT_DECL_ATTRIBUTES (decl1, attrs);
13567 #endif
13568
13569   /* This function exists in static storage.
13570      (This does not mean `static' in the C sense!)  */
13571   TREE_STATIC (decl1) = 1;
13572
13573   /* We must call push_template_decl after current_class_type is set
13574      up.  (If we are processing inline definitions after exiting a
13575      class scope, current_class_type will be NULL_TREE until set above
13576      by push_nested_class.)  */
13577   if (processing_template_decl)
13578     decl1 = push_template_decl (decl1);
13579
13580   /* We are now in the scope of the function being defined.  */
13581   current_function_decl = decl1;
13582
13583   /* Save the parm names or decls from this function's declarator
13584      where store_parm_decls will find them.  */
13585   current_function_parms = last_function_parms;
13586   current_function_parm_tags = last_function_parm_tags;
13587
13588   /* Make sure the parameter and return types are reasonable.  When
13589      you declare a function, these types can be incomplete, but they
13590      must be complete when you define the function.  */
13591   if (! processing_template_decl)
13592     check_function_type (decl1);
13593
13594   /* Build the return declaration for the function.  */
13595   restype = TREE_TYPE (fntype);
13596   if (!processing_template_decl)
13597     {
13598       if (!DECL_RESULT (decl1))
13599         {
13600           DECL_RESULT (decl1)
13601             = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13602           c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype),
13603                                       DECL_RESULT (decl1));
13604         }
13605     }
13606   else
13607     /* Just use `void'.  Nobody will ever look at this anyhow.  */
13608     DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, void_type_node);
13609
13610   /* Initialize RTL machinery.  We cannot do this until
13611      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
13612      even when processing a template; this is how we get
13613      CFUN set up, and our per-function variables initialized.  */
13614   bl = current_binding_level;
13615   init_function_start (decl1, input_filename, lineno);
13616   current_binding_level = bl;
13617   expanding_p = (flags & SF_EXPAND) != 0;
13618
13619   /* Even though we're inside a function body, we still don't want to
13620      call expand_expr to calculate the size of a variable-sized array.
13621      We haven't necessarily assigned RTL to all variables yet, so it's
13622      not safe to try to expand expressions involving them.  */
13623   immediate_size_expand = 0;
13624   cfun->x_dont_save_pending_sizes_p = 1;
13625
13626   /* If we're building a statement-tree, start the tree now.  */
13627   if (processing_template_decl || !expanding_p)
13628     begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13629
13630   /* Let the user know we're compiling this function.  */
13631   announce_function (decl1);
13632
13633   /* Record the decl so that the function name is defined.
13634      If we already have a decl for this name, and it is a FUNCTION_DECL,
13635      use the old decl.  */
13636   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13637     {
13638       /* A specialization is not used to guide overload resolution.  */
13639       if (!DECL_TEMPLATE_SPECIALIZATION (decl1)
13640           && ! DECL_FUNCTION_MEMBER_P (decl1))
13641         decl1 = pushdecl (decl1);
13642       else
13643         {
13644           /* We need to set the DECL_CONTEXT. */
13645           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13646             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13647           /* And make sure we have enough default args.  */
13648           check_default_args (decl1);
13649         }
13650       fntype = TREE_TYPE (decl1);
13651     }
13652
13653   /* Reset these in case the call to pushdecl changed them.  */
13654   current_function_decl = decl1;
13655   cfun->decl = decl1;
13656
13657   /* Initialize the per-function data.  */
13658   if (!DECL_PENDING_INLINE_P (decl1) && DECL_SAVED_FUNCTION_DATA (decl1))
13659     {
13660       /* If we already parsed this function, and we're just expanding it
13661          now, restore saved state.  */
13662       struct binding_level *bl = current_binding_level;
13663       *cp_function_chain = *DECL_SAVED_FUNCTION_DATA (decl1);
13664       current_binding_level = bl;
13665
13666       /* This function is being processed in whole-function mode; we
13667          already did semantic analysis.  */
13668       cfun->x_whole_function_mode_p = 1;
13669
13670       /* If we decided that we didn't want to inline this function,
13671          make sure the back-end knows that.  */
13672       if (!current_function_cannot_inline)
13673         current_function_cannot_inline = cp_function_chain->cannot_inline;
13674
13675       /* We don't need the saved data anymore.  */
13676       free (DECL_SAVED_FUNCTION_DATA (decl1));
13677       DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13678     }
13679   else if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13680     {
13681       /* We know that this was set up by `grokclassfn'.  We do not
13682          wait until `store_parm_decls', since evil parse errors may
13683          never get us to that point.  Here we keep the consistency
13684          between `current_class_type' and `current_class_ptr'.  */
13685       tree t = DECL_ARGUMENTS (decl1);
13686
13687       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13688                           162);
13689       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13690                           19990811);
13691
13692       cp_function_chain->x_current_class_ref
13693         = build_indirect_ref (t, NULL_PTR);
13694       cp_function_chain->x_current_class_ptr = t;
13695
13696       /* Constructors and destructors need to know whether they're "in
13697          charge" of initializing virtual base classes.  */
13698       if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
13699         current_in_charge_parm = TREE_CHAIN (t);
13700     }
13701
13702   if (DECL_INTERFACE_KNOWN (decl1))
13703     {
13704       tree ctx = decl_function_context (decl1);
13705
13706       if (DECL_NOT_REALLY_EXTERN (decl1))
13707         DECL_EXTERNAL (decl1) = 0;
13708
13709       if (ctx != NULL_TREE && DECL_THIS_INLINE (ctx)
13710           && TREE_PUBLIC (ctx))
13711         /* This is a function in a local class in an extern inline
13712            function.  */
13713         comdat_linkage (decl1);
13714     }
13715   /* If this function belongs to an interface, it is public.
13716      If it belongs to someone else's interface, it is also external.
13717      This only affects inlines and template instantiations.  */
13718   else if (interface_unknown == 0
13719            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13720                || flag_alt_external_templates))
13721     {
13722       if (DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1)
13723           || processing_template_decl)
13724         {
13725           DECL_EXTERNAL (decl1)
13726             = (interface_only
13727                || (DECL_THIS_INLINE (decl1) && ! flag_implement_inlines
13728                    && !DECL_VINDEX (decl1)));
13729
13730           /* For WIN32 we also want to put these in linkonce sections.  */
13731           maybe_make_one_only (decl1);
13732         }
13733       else
13734         DECL_EXTERNAL (decl1) = 0;
13735       DECL_NOT_REALLY_EXTERN (decl1) = 0;
13736       DECL_INTERFACE_KNOWN (decl1) = 1;
13737     }
13738   else if (interface_unknown && interface_only
13739            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13740                || flag_alt_external_templates))
13741     {
13742       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13743          interface, we will have interface_only set but not
13744          interface_known.  In that case, we don't want to use the normal
13745          heuristics because someone will supply a #pragma implementation
13746          elsewhere, and deducing it here would produce a conflict.  */
13747       comdat_linkage (decl1);
13748       DECL_EXTERNAL (decl1) = 0;
13749       DECL_INTERFACE_KNOWN (decl1) = 1;
13750       DECL_DEFER_OUTPUT (decl1) = 1;
13751     }
13752   else
13753     {
13754       /* This is a definition, not a reference.
13755          So clear DECL_EXTERNAL.  */
13756       DECL_EXTERNAL (decl1) = 0;
13757
13758       if ((DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1))
13759           && ! DECL_INTERFACE_KNOWN (decl1)
13760           /* Don't try to defer nested functions for now.  */
13761           && ! decl_function_context (decl1))
13762         DECL_DEFER_OUTPUT (decl1) = 1;
13763       else
13764         DECL_INTERFACE_KNOWN (decl1) = 1;
13765     }
13766
13767   if (doing_semantic_analysis_p ())
13768     {
13769       pushlevel (0);
13770       current_binding_level->parm_flag = 1;
13771     }
13772
13773   if (attrs)
13774     cplus_decl_attributes (decl1, NULL_TREE, attrs);
13775
13776   if (!building_stmt_tree ())
13777     {
13778       GNU_xref_function (decl1, current_function_parms);
13779       make_function_rtl (decl1);
13780     }
13781
13782   /* Promote the value to int before returning it.  */
13783   if (C_PROMOTING_INTEGER_TYPE_P (restype))
13784     restype = type_promotes_to (restype);
13785
13786   /* If this fcn was already referenced via a block-scope `extern' decl
13787      (or an implicit decl), propagate certain information about the usage.  */
13788   if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1)))
13789     TREE_ADDRESSABLE (decl1) = 1;
13790
13791   if (DECL_RESULT (decl1) == NULL_TREE)
13792     {
13793       DECL_RESULT (decl1)
13794         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13795       TREE_READONLY (DECL_RESULT (decl1)) = CP_TYPE_CONST_P (restype);
13796       TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = CP_TYPE_VOLATILE_P (restype);
13797     }
13798
13799   ++function_depth;
13800
13801   if (DECL_DESTRUCTOR_P (decl1))
13802     {
13803       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13804       DECL_CONTEXT (dtor_label) = current_function_decl;
13805     }
13806   /* Under the old ABI we return `this' from constructors, so we make
13807      ordinary `return' statements in constructors jump to CTOR_LABEL;
13808      from there we return `this'.  Under the new ABI, we don't bother
13809      with any of this.  By not setting CTOR_LABEL the remainder of the
13810      machinery is automatically disabled.  */
13811   else if (!flag_new_abi && DECL_CONSTRUCTOR_P (decl1))
13812     {
13813       ctor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13814       DECL_CONTEXT (ctor_label) = current_function_decl;
13815     }
13816
13817   return 1;
13818 }
13819 \f
13820 /* Called after store_parm_decls for a function-try-block.  */
13821
13822 void
13823 expand_start_early_try_stmts ()
13824 {
13825   expand_start_try_stmts ();
13826 }
13827
13828 /* Store the parameter declarations into the current function declaration.
13829    This is called after parsing the parameter declarations, before
13830    digesting the body of the function.
13831
13832    Also install to binding contour return value identifier, if any.  */
13833
13834 void
13835 store_parm_decls ()
13836 {
13837   register tree fndecl = current_function_decl;
13838   register tree parm;
13839   int parms_have_cleanups = 0;
13840   tree cleanups = NULL_TREE;
13841
13842   /* This is a list of types declared among parms in a prototype.  */
13843   tree parmtags = current_function_parm_tags;
13844
13845   /* This is a chain of any other decls that came in among the parm
13846      declarations.  If a parm is declared with  enum {foo, bar} x;
13847      then CONST_DECLs for foo and bar are put here.  */
13848   tree nonparms = NULL_TREE;
13849
13850   /* Create a binding level for the parms.  */
13851   if (!building_stmt_tree ())
13852     expand_start_bindings (2);
13853
13854   if (current_function_parms)
13855     {
13856       /* This case is when the function was defined with an ANSI prototype.
13857          The parms already have decls, so we need not do anything here
13858          except record them as in effect
13859          and complain if any redundant old-style parm decls were written.  */
13860
13861       tree specparms = current_function_parms;
13862       tree next;
13863
13864       if (doing_semantic_analysis_p ())
13865         {
13866           /* Must clear this because it might contain TYPE_DECLs declared
13867              at class level.  */
13868           storedecls (NULL_TREE);
13869
13870           /* If we're doing semantic analysis, then we'll call pushdecl
13871              for each of these.  We must do them in reverse order so that
13872              they end in the correct forward order.  */
13873           specparms = nreverse (specparms);
13874         }
13875
13876       for (parm = specparms; parm; parm = next)
13877         {
13878           next = TREE_CHAIN (parm);
13879           if (TREE_CODE (parm) == PARM_DECL)
13880             {
13881               tree type = TREE_TYPE (parm);
13882
13883               if (doing_semantic_analysis_p ())
13884                 {
13885                   tree cleanup;
13886
13887                   if (DECL_NAME (parm) == NULL_TREE
13888                       || TREE_CODE (parm) != VOID_TYPE)
13889                     pushdecl (parm);
13890                   else
13891                     cp_error ("parameter `%D' declared void", parm);
13892
13893                   cleanup = (processing_template_decl
13894                              ? NULL_TREE
13895                              : maybe_build_cleanup (parm));
13896
13897                   if (cleanup)
13898                     cleanups = tree_cons (parm, cleanup, cleanups);
13899                 }
13900               else if (type != error_mark_node
13901                        && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
13902                 parms_have_cleanups = 1;
13903             }
13904           else
13905             {
13906               /* If we find an enum constant or a type tag,
13907                  put it aside for the moment.  */
13908               TREE_CHAIN (parm) = NULL_TREE;
13909               nonparms = chainon (nonparms, parm);
13910             }
13911         }
13912
13913       if (doing_semantic_analysis_p ())
13914         {
13915           /* Get the decls in their original chain order
13916              and record in the function.  This is all and only the
13917              PARM_DECLs that were pushed into scope by the loop above.  */
13918           DECL_ARGUMENTS (fndecl) = getdecls ();
13919           storetags (chainon (parmtags, gettags ()));
13920         }
13921     }
13922   else
13923     DECL_ARGUMENTS (fndecl) = NULL_TREE;
13924
13925   /* Now store the final chain of decls for the arguments
13926      as the decl-chain of the current lexical scope.
13927      Put the enumerators in as well, at the front so that
13928      DECL_ARGUMENTS is not modified.  */
13929   if (doing_semantic_analysis_p ())
13930     storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
13931
13932   /* Initialize the RTL code for the function.  */
13933   DECL_SAVED_INSNS (fndecl) = 0;
13934   if (! building_stmt_tree ())
13935     expand_function_start (fndecl, parms_have_cleanups);
13936
13937   current_function_parms_stored = 1;
13938
13939   /* If this function is `main', emit a call to `__main'
13940      to run global initializers, etc.  */
13941   if (DECL_MAIN_P (fndecl) && !building_stmt_tree ())
13942     expand_main_function ();
13943
13944   /* Now that we have initialized the parms, we can start their
13945      cleanups.  We cannot do this before, since expand_decl_cleanup
13946      should not be called before the parm can be used.  */
13947   while (cleanups)
13948     {
13949       finish_decl_cleanup (TREE_PURPOSE (cleanups),
13950                            TREE_VALUE (cleanups));
13951       cleanups = TREE_CHAIN (cleanups);
13952     }
13953
13954   /* Create a binding contour which can be used to catch
13955      cleanup-generated temporaries.  Also, if the return value needs or
13956      has initialization, deal with that now.  */
13957   if (parms_have_cleanups)
13958     {
13959       pushlevel (0);
13960       if (!building_stmt_tree ())
13961         expand_start_bindings (2);
13962     }
13963
13964   /* Do the starting of the exception specifications, if we have any.  */
13965   if (flag_exceptions && !processing_template_decl
13966       && flag_enforce_eh_specs
13967       && building_stmt_tree ()
13968       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13969     current_eh_spec_try_block = expand_start_eh_spec ();
13970 }
13971
13972 /* Bind a name and initialization to the return value of
13973    the current function.  */
13974
13975 void
13976 store_return_init (decl)
13977      tree decl;
13978 {
13979   /* If this named return value comes in a register, put it in a
13980      pseudo-register.  */
13981   if (DECL_REGISTER (decl))
13982     {
13983       original_result_rtx = DECL_RTL (decl);
13984       /* Note that the mode of the old DECL_RTL may be wider than the
13985          mode of DECL_RESULT, depending on the calling conventions for
13986          the processor.  For example, on the Alpha, a 32-bit integer
13987          is returned in a DImode register -- the DECL_RESULT has
13988          SImode but the DECL_RTL for the DECL_RESULT has DImode.  So,
13989          here, we use the mode the back-end has already assigned for
13990          the return value.  */
13991       DECL_RTL (decl) = gen_reg_rtx (GET_MODE (original_result_rtx));
13992       if (TREE_ADDRESSABLE (decl))
13993         put_var_into_stack (decl);
13994     }
13995 }
13996
13997 \f
13998 /* We have finished doing semantic analysis on DECL, but have not yet
13999    generated RTL for its body.  Save away our current state, so that
14000    when we want to generate RTL later we know what to do.  */
14001
14002 static void
14003 save_function_data (decl)
14004      tree decl;
14005 {
14006   struct language_function *f;
14007
14008   /* Save the language-specific per-function data so that we can
14009      get it back when we really expand this function.  */
14010   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
14011                       19990908);
14012
14013   /* Make a copy.  */
14014   f = ((struct language_function *)
14015        xmalloc (sizeof (struct language_function)));
14016   bcopy ((char *) cp_function_chain, (char *) f,
14017          sizeof (struct language_function));
14018   DECL_SAVED_FUNCTION_DATA (decl) = f;
14019
14020   /* Clear out the bits we don't need.  */
14021   f->x_stmt_tree.x_last_stmt = NULL_TREE;
14022   f->x_stmt_tree.x_last_expr_type = NULL_TREE;
14023   f->x_result_rtx = NULL_RTX;
14024   f->x_named_label_uses = NULL;
14025   f->bindings = NULL;
14026
14027   /* When we get back here again, we will be expanding.  */
14028   f->x_expanding_p = 1;
14029
14030   /* If we've already decided that we cannot inline this function, we
14031      must remember that fact when we actually go to expand the
14032      function.  */
14033   f->cannot_inline = current_function_cannot_inline;
14034 }
14035
14036 /* At the end of every constructor we generate to code to return
14037    `this'.  Do that now.  */
14038
14039 static void
14040 finish_constructor_body ()
14041 {
14042   /* Any return from a constructor will end up here.  */
14043   if (ctor_label)
14044     add_tree (build_stmt (LABEL_STMT, ctor_label));
14045
14046   /* Clear CTOR_LABEL so that finish_return_stmt knows to really
14047      generate the return, rather than a goto to CTOR_LABEL.  */
14048   ctor_label = NULL_TREE;
14049   /* In check_return_expr we translate an empty return from a
14050      constructor to a return of `this'.  */
14051   finish_return_stmt (NULL_TREE);
14052   /* Mark the end of the constructor.  */
14053   add_tree (build_stmt (CTOR_STMT));
14054 }
14055
14056 /* At the end of every destructor we generate code to restore virtual
14057    function tables to the values desired by base classes and to call
14058    to base class destructors.  Do that now.  */
14059
14060 static void
14061 finish_destructor_body ()
14062 {
14063   tree compound_stmt;
14064   tree virtual_size;
14065   tree exprstmt;
14066   tree if_stmt;
14067
14068   /* Create a block to contain all the extra code.  */
14069   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
14070
14071   /* Any return from a destructor will end up here.  */
14072   add_tree (build_stmt (LABEL_STMT, dtor_label));
14073
14074   /* Generate the code to call destructor on base class.  If this
14075      destructor belongs to a class with virtual functions, then set
14076      the virtual function table pointer to represent the type of our
14077      base class.  */
14078
14079   /* This side-effect makes call to `build_delete' generate the code
14080      we have to have at the end of this destructor.  `build_delete'
14081      will set the flag again.  */
14082   TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
14083
14084   exprstmt = build_delete (current_class_type,
14085                            current_class_ref,
14086                            sfk_base_destructor,
14087                            LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
14088                            0);
14089
14090   if (exprstmt != error_mark_node
14091       && (TREE_CODE (exprstmt) != NOP_EXPR
14092           || TREE_OPERAND (exprstmt, 0) != integer_zero_node
14093           || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
14094     {
14095       if (exprstmt != void_zero_node)
14096         /* Don't call `expand_expr_stmt' if we're not going to do
14097            anything, since -Wall will give a diagnostic.  */
14098         finish_expr_stmt (exprstmt);
14099
14100       /* Run destructors for all virtual baseclasses.  */
14101       if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
14102         {
14103           tree vbases;
14104           tree if_stmt;
14105
14106           if_stmt = begin_if_stmt ();
14107           finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
14108                                       current_in_charge_parm,
14109                                       integer_two_node),
14110                                if_stmt);
14111
14112           vbases = CLASSTYPE_VBASECLASSES (current_class_type);
14113           /* The CLASSTYPE_VBASECLASSES list is in initialization
14114              order, so we have to march through it in reverse order.  */
14115           for (vbases = nreverse (copy_list (vbases));
14116                vbases;
14117                vbases = TREE_CHAIN (vbases))
14118             {
14119               tree vbase = TREE_VALUE (vbases);
14120
14121               if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (vbase)))
14122                 {
14123                   tree vb = get_vbase
14124                     (BINFO_TYPE (vbase),
14125                      TYPE_BINFO (current_class_type));
14126                   finish_expr_stmt
14127                     (build_scoped_method_call
14128                      (current_class_ref, vb, base_dtor_identifier,
14129                       NULL_TREE));
14130                 }
14131             }
14132
14133           finish_then_clause (if_stmt);
14134           finish_if_stmt ();
14135         }
14136     }
14137
14138   virtual_size = c_sizeof (current_class_type);
14139
14140   /* At the end, call delete if that's what's requested.  */
14141
14142   /* FDIS sez: At the point of definition of a virtual destructor
14143      (including an implicit definition), non-placement operator delete
14144      shall be looked up in the scope of the destructor's class and if
14145      found shall be accessible and unambiguous.
14146
14147      This is somewhat unclear, but I take it to mean that if the class
14148      only defines placement deletes we don't do anything here.  So we
14149      pass LOOKUP_SPECULATIVELY; delete_sanity will complain for us if
14150      they ever try to delete one of these.  */
14151   exprstmt = build_op_delete_call
14152     (DELETE_EXPR, current_class_ptr, virtual_size,
14153      LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
14154
14155   if_stmt = begin_if_stmt ();
14156   finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
14157                               current_in_charge_parm,
14158                               integer_one_node),
14159                        if_stmt);
14160   finish_expr_stmt (exprstmt);
14161   finish_then_clause (if_stmt);
14162   finish_if_stmt ();
14163
14164   /* Close the block we started above.  */
14165   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
14166 }
14167
14168 /* Finish up a function declaration and compile that function
14169    all the way to assembler language output.  The free the storage
14170    for the function definition.
14171
14172    FLAGS is a bitwise or of the following values:
14173      1 - CALL_POPLEVEL
14174        An extra call to poplevel (and expand_end_bindings) must be
14175        made to take care of the binding contour for the base
14176        initializers.  This is only relevant for constructors.
14177      2 - INCLASS_INLINE
14178        We just finished processing the body of an in-class inline
14179        function definition.  (This processing will have taken place
14180        after the class definition is complete.)  */
14181
14182 tree
14183 finish_function (flags)
14184      int flags;
14185 {
14186   register tree fndecl = current_function_decl;
14187   tree fntype, ctype = NULL_TREE;
14188   /* Label to use if this function is supposed to return a value.  */
14189   tree no_return_label = NULL_TREE;
14190   int call_poplevel = (flags & 1) != 0;
14191   int inclass_inline = (flags & 2) != 0;
14192   int expand_p;
14193   int nested;
14194   int current_line = lineno;
14195
14196   /* When we get some parse errors, we can end up without a
14197      current_function_decl, so cope.  */
14198   if (fndecl == NULL_TREE)
14199     return error_mark_node;
14200
14201   nested = function_depth > 1;
14202   fntype = TREE_TYPE (fndecl);
14203
14204   /*  TREE_READONLY (fndecl) = 1;
14205       This caused &foo to be of type ptr-to-const-function
14206       which then got a warning when stored in a ptr-to-function variable.  */
14207
14208   /* This happens on strange parse errors.  */
14209   if (! current_function_parms_stored)
14210     {
14211       call_poplevel = 0;
14212       store_parm_decls ();
14213     }
14214
14215   /* For a cloned function, we've already got all the code we need;
14216      there's no need to add any extra bits.  */
14217   if (building_stmt_tree () && DECL_CLONED_FUNCTION_P (fndecl))
14218     ;
14219   else if (building_stmt_tree ())
14220     {
14221       if (DECL_CONSTRUCTOR_P (fndecl))
14222         {
14223           finish_constructor_body ();
14224           if (call_poplevel)
14225             do_poplevel ();
14226         }
14227       else if (DECL_DESTRUCTOR_P (fndecl) && !processing_template_decl)
14228         finish_destructor_body ();
14229       else if (DECL_MAIN_P (fndecl))
14230         {
14231           /* Make it so that `main' always returns 0 by default.  */
14232 #ifdef VMS
14233           finish_return_stmt (integer_one_node);
14234 #else
14235           finish_return_stmt (integer_zero_node);
14236 #endif
14237         }
14238
14239       /* Finish dealing with exception specifiers.  */
14240       if (flag_exceptions && !processing_template_decl
14241           && flag_enforce_eh_specs
14242           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14243         expand_end_eh_spec (TYPE_RAISES_EXCEPTIONS
14244                             (TREE_TYPE (current_function_decl)),
14245                             current_eh_spec_try_block);
14246     }
14247   else
14248     {
14249 #if 0
14250       if (write_symbols != NO_DEBUG /*&& TREE_CODE (fntype) != METHOD_TYPE*/)
14251         {
14252           /* Keep this code around in case we later want to control debug info
14253              based on whether a type is "used".  (jason 1999-11-11) */
14254
14255           tree ttype = target_type (fntype);
14256           tree parmdecl;
14257
14258           if (IS_AGGR_TYPE (ttype))
14259             /* Let debugger know it should output info for this type.  */
14260             note_debug_info_needed (ttype);
14261
14262           for (parmdecl = DECL_ARGUMENTS (fndecl); parmdecl; parmdecl = TREE_CHAIN (parmdecl))
14263             {
14264               ttype = target_type (TREE_TYPE (parmdecl));
14265               if (IS_AGGR_TYPE (ttype))
14266                 /* Let debugger know it should output info for this type.  */
14267                 note_debug_info_needed (ttype);
14268             }
14269         }
14270 #endif
14271
14272       /* Clean house because we will need to reorder insns here.  */
14273       do_pending_stack_adjust ();
14274
14275       if (dtor_label)
14276         ;
14277       else if (DECL_CONSTRUCTOR_P (fndecl))
14278         {
14279           if (call_poplevel)
14280             do_poplevel ();
14281         }
14282       else if (return_label != NULL_RTX
14283                && flag_this_is_variable <= 0
14284                && current_function_return_value == NULL_TREE
14285                && ! DECL_NAME (DECL_RESULT (current_function_decl)))
14286         no_return_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
14287
14288       if (flag_exceptions)
14289         expand_exception_blocks ();
14290
14291       /* If this function is supposed to return a value, ensure that
14292          we do not fall into the cleanups by mistake.  The end of our
14293          function will look like this:
14294
14295          user code (may have return stmt somewhere)
14296          goto no_return_label
14297          cleanup_label:
14298          cleanups
14299          goto return_label
14300          no_return_label:
14301          NOTE_INSN_FUNCTION_END
14302          return_label:
14303          things for return
14304
14305          If the user omits a return stmt in the USER CODE section, we
14306          will have a control path which reaches NOTE_INSN_FUNCTION_END.
14307          Otherwise, we won't.  */
14308       if (no_return_label)
14309         {
14310           DECL_CONTEXT (no_return_label) = fndecl;
14311           DECL_INITIAL (no_return_label) = error_mark_node;
14312           DECL_SOURCE_FILE (no_return_label) = input_filename;
14313           DECL_SOURCE_LINE (no_return_label) = current_line;
14314           expand_goto (no_return_label);
14315         }
14316
14317       if (cleanup_label)
14318         {
14319           /* Remove the binding contour which is used
14320              to catch cleanup-generated temporaries.  */
14321           expand_end_bindings (0, 0, 0);
14322           poplevel (0, 0, 0);
14323
14324           /* Emit label at beginning of cleanup code for parameters.  */
14325           emit_label (cleanup_label);
14326         }
14327
14328       /* Get return value into register if that's where it's supposed
14329          to be.  */
14330       if (original_result_rtx)
14331         fixup_result_decl (DECL_RESULT (fndecl), original_result_rtx);
14332
14333       /* Finish building code that will trigger warnings if users forget
14334          to make their functions return values.  */
14335       if (no_return_label || cleanup_label)
14336         emit_jump (return_label);
14337       if (no_return_label)
14338         {
14339           /* We don't need to call `expand_*_return' here because we
14340              don't need any cleanups here--this path of code is only
14341              for error checking purposes.  */
14342           expand_label (no_return_label);
14343         }
14344
14345       /* We hard-wired immediate_size_expand to zero in
14346          start_function.  Expand_function_end will decrement this
14347          variable.  So, we set the variable to one here, so that after
14348          the decrement it will remain zero.  */
14349       immediate_size_expand = 1;
14350
14351       /* Generate rtl for function exit.  */
14352       expand_function_end (input_filename, current_line, 1);
14353     }
14354
14355   /* We have to save this value here in case
14356      maybe_end_member_template_processing decides to pop all the
14357      template parameters.  */
14358   expand_p = !building_stmt_tree ();
14359
14360   /* If we're saving up tree structure, tie off the function now.  */
14361   if (!expand_p)
14362     finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
14363
14364   /* This must come after expand_function_end because cleanups might
14365      have declarations (from inline functions) that need to go into
14366      this function's blocks.  */
14367   if (doing_semantic_analysis_p ())
14368     {
14369       if (current_binding_level->parm_flag != 1)
14370         my_friendly_abort (122);
14371       poplevel (1, 0, 1);
14372     }
14373
14374   /* Remember that we were in class scope.  */
14375   if (current_class_name)
14376     ctype = current_class_type;
14377
14378   /* Must mark the RESULT_DECL as being in this function.  */
14379   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
14380
14381   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14382      to the FUNCTION_DECL node itself.  */
14383   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
14384
14385   /* Save away current state, if appropriate.  */
14386   if (!expanding_p && !processing_template_decl)
14387     save_function_data (fndecl);
14388
14389   /* If this function calls `setjmp' it cannot be inlined.  When
14390      `longjmp' is called it is not guaranteed to restore the value of
14391      local variables that have been modified since the call to
14392      `setjmp'.  So, if were to inline this function into some caller
14393      `c', then when we `longjmp', we might not restore all variables
14394      in `c'.  (It might seem, at first blush, that there's no way for
14395      this function to modify local variables in `c', but their
14396      addresses may have been stored somewhere accessible to this
14397      function.)  */
14398   if (!expanding_p && !processing_template_decl && calls_setjmp_p (fndecl))
14399     DECL_UNINLINABLE (fndecl) = 1;
14400
14401   if (expand_p)
14402     {
14403       int returns_null;
14404       int returns_value;
14405
14406       /* So we can tell if jump_optimize sets it to 1.  */
14407       can_reach_end = 0;
14408
14409       /* Before we call rest_of_compilation (which will pop the
14410          CURRENT_FUNCTION), we must save these values.  */
14411       returns_null = current_function_returns_null;
14412       returns_value = current_function_returns_value;
14413
14414       /* If this is a nested function (like a template instantiation
14415          that we're compiling in the midst of compiling something
14416          else), push a new GC context.  That will keep local variables
14417          on the stack from being collected while we're doing the
14418          compilation of this function.  */
14419       if (function_depth > 1)
14420         ggc_push_context ();
14421
14422       /* Run the optimizers and output the assembler code for this
14423          function.  */
14424       rest_of_compilation (fndecl);
14425
14426       /* Undo the call to ggc_push_context above.  */
14427       if (function_depth > 1)
14428         ggc_pop_context ();
14429
14430       if (DECL_SAVED_INSNS (fndecl) && ! TREE_ASM_WRITTEN (fndecl))
14431         {
14432           /* Set DECL_EXTERNAL so that assemble_external will be called as
14433              necessary.  We'll clear it again in finish_file.  */
14434           if (! DECL_EXTERNAL (fndecl))
14435             DECL_NOT_REALLY_EXTERN (fndecl) = 1;
14436           DECL_EXTERNAL (fndecl) = 1;
14437           defer_fn (fndecl);
14438         }
14439
14440 #if 0
14441       /* Keep this code around in case we later want to control debug info
14442          based on whether a type is "used".  (jason 1999-11-11) */
14443
14444       if (ctype && TREE_ASM_WRITTEN (fndecl))
14445         note_debug_info_needed (ctype);
14446 #endif
14447
14448       if (DECL_NAME (DECL_RESULT (fndecl)))
14449         returns_value |= can_reach_end;
14450       else
14451         returns_null |= can_reach_end;
14452
14453       if (TREE_THIS_VOLATILE (fndecl) && returns_null)
14454         warning ("`noreturn' function does return");
14455       else if (returns_null
14456                && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE)
14457         {
14458           /* Always complain if there's just no return statement.  */
14459           if (!returns_value)
14460             warning ("no return statement in function returning non-void");
14461           else if (warn_return_type || pedantic)
14462             /* If this function returns non-void and control can drop through,
14463                complain.  */
14464             warning ("control reaches end of non-void function");
14465         }
14466     }
14467   else
14468     {
14469       /* Clear out memory we no longer need.  */
14470       free_after_parsing (cfun);
14471       /* Since we never call rest_of_compilation, we never clear
14472          CFUN.  Do so explicitly.  */
14473       free_after_compilation (cfun);
14474       cfun = NULL;
14475     }
14476
14477   /* If this is a in-class inline definition, we may have to pop the
14478      bindings for the template parameters that we added in
14479      maybe_begin_member_template_processing when start_function was
14480      called.  */
14481   if (inclass_inline)
14482     maybe_end_member_template_processing ();
14483
14484   /* Leave the scope of the class.  */
14485   if (ctype)
14486     pop_nested_class ();
14487
14488   --function_depth;
14489
14490   if (!DECL_SAVED_INSNS (fndecl) && !DECL_SAVED_FUNCTION_DATA (fndecl)
14491       && !(flag_inline_trees && DECL_INLINE (fndecl)))
14492     {
14493       tree t;
14494
14495       /* Stop pointing to the local nodes about to be freed.  */
14496       /* But DECL_INITIAL must remain nonzero so we know this
14497          was an actual function definition.  */
14498       DECL_INITIAL (fndecl) = error_mark_node;
14499       for (t = DECL_ARGUMENTS (fndecl); t; t = TREE_CHAIN (t))
14500         DECL_RTL (t) = DECL_INCOMING_RTL (t) = NULL_RTX;
14501     }
14502
14503   if (DECL_STATIC_CONSTRUCTOR (fndecl))
14504     static_ctors = tree_cons (NULL_TREE, fndecl, static_ctors);
14505   if (DECL_STATIC_DESTRUCTOR (fndecl))
14506     static_dtors = tree_cons (NULL_TREE, fndecl, static_dtors);
14507
14508   /* Clean up.  */
14509   if (! nested)
14510     {
14511       /* Let the error reporting routines know that we're outside a
14512          function.  For a nested function, this value is used in
14513          pop_cp_function_context and then reset via pop_function_context.  */
14514       current_function_decl = NULL_TREE;
14515       /* We don't really care about obstacks, but the middle-end
14516          sometimes cares on what obstck things are located.  */
14517       permanent_allocation (1);
14518     }
14519
14520   return fndecl;
14521 }
14522 \f
14523 /* Create the FUNCTION_DECL for a function definition.
14524    DECLSPECS and DECLARATOR are the parts of the declaration;
14525    they describe the return type and the name of the function,
14526    but twisted together in a fashion that parallels the syntax of C.
14527
14528    This function creates a binding context for the function body
14529    as well as setting up the FUNCTION_DECL in current_function_decl.
14530
14531    Returns a FUNCTION_DECL on success.
14532
14533    If the DECLARATOR is not suitable for a function (it defines a datum
14534    instead), we return 0, which tells yyparse to report a parse error.
14535
14536    May return void_type_node indicating that this method is actually
14537    a friend.  See grokfield for more details.
14538
14539    Came here with a `.pushlevel' .
14540
14541    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14542    CHANGES TO CODE IN `grokfield'.  */
14543
14544 tree
14545 start_method (declspecs, declarator, attrlist)
14546      tree declarator, declspecs, attrlist;
14547 {
14548   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14549                                 attrlist);
14550
14551   /* Something too ugly to handle.  */
14552   if (fndecl == NULL_TREE)
14553     return NULL_TREE;
14554
14555   /* Pass friends other than inline friend functions back.  */
14556   if (fndecl == void_type_node)
14557     return fndecl;
14558
14559   if (TREE_CODE (fndecl) != FUNCTION_DECL)
14560     /* Not a function, tell parser to report parse error.  */
14561     return NULL_TREE;
14562
14563   if (DECL_IN_AGGR_P (fndecl))
14564     {
14565       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14566         {
14567           if (DECL_CONTEXT (fndecl)
14568               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14569             cp_error ("`%D' is already defined in class %s", fndecl,
14570                              TYPE_NAME_STRING (DECL_CONTEXT (fndecl)));
14571         }
14572       return void_type_node;
14573     }
14574
14575   check_template_shadow (fndecl);
14576
14577   DECL_THIS_INLINE (fndecl) = 1;
14578
14579   if (flag_default_inline)
14580     DECL_INLINE (fndecl) = 1;
14581
14582   /* We process method specializations in finish_struct_1.  */
14583   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14584     fndecl = push_template_decl (fndecl);
14585
14586   if (! DECL_FRIEND_P (fndecl))
14587     {
14588       if (TREE_CHAIN (fndecl))
14589         {
14590           fndecl = copy_node (fndecl);
14591           TREE_CHAIN (fndecl) = NULL_TREE;
14592         }
14593
14594       if (DECL_CONSTRUCTOR_P (fndecl))
14595         {
14596           if (! grok_ctor_properties (current_class_type, fndecl))
14597             return void_type_node;
14598         }
14599       else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl)))
14600         grok_op_properties (fndecl, DECL_VIRTUAL_P (fndecl), 0);
14601     }
14602
14603   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14604
14605   /* Make a place for the parms */
14606   pushlevel (0);
14607   current_binding_level->parm_flag = 1;
14608
14609   DECL_IN_AGGR_P (fndecl) = 1;
14610   return fndecl;
14611 }
14612
14613 /* Go through the motions of finishing a function definition.
14614    We don't compile this method until after the whole class has
14615    been processed.
14616
14617    FINISH_METHOD must return something that looks as though it
14618    came from GROKFIELD (since we are defining a method, after all).
14619
14620    This is called after parsing the body of the function definition.
14621    STMTS is the chain of statements that makes up the function body.
14622
14623    DECL is the ..._DECL that `start_method' provided.  */
14624
14625 tree
14626 finish_method (decl)
14627      tree decl;
14628 {
14629   register tree fndecl = decl;
14630   tree old_initial;
14631
14632   register tree link;
14633
14634   if (decl == void_type_node)
14635     return decl;
14636
14637   old_initial = DECL_INITIAL (fndecl);
14638
14639   /* Undo the level for the parms (from start_method).
14640      This is like poplevel, but it causes nothing to be
14641      saved.  Saving information here confuses symbol-table
14642      output routines.  Besides, this information will
14643      be correctly output when this method is actually
14644      compiled.  */
14645
14646   /* Clear out the meanings of the local variables of this level;
14647      also record in each decl which block it belongs to.  */
14648
14649   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14650     {
14651       if (DECL_NAME (link) != NULL_TREE)
14652         pop_binding (DECL_NAME (link), link);
14653       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14654       DECL_CONTEXT (link) = NULL_TREE;
14655     }
14656
14657   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
14658                       (HOST_WIDE_INT) current_binding_level->level_chain,
14659                       current_binding_level->parm_flag,
14660                       current_binding_level->keep);
14661
14662   poplevel (0, 0, 0);
14663
14664   DECL_INITIAL (fndecl) = old_initial;
14665
14666   /* We used to check if the context of FNDECL was different from
14667      current_class_type as another way to get inside here.  This didn't work
14668      for String.cc in libg++.  */
14669   if (DECL_FRIEND_P (fndecl))
14670     {
14671       CLASSTYPE_INLINE_FRIENDS (current_class_type)
14672         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14673       decl = void_type_node;
14674     }
14675
14676   return decl;
14677 }
14678 \f
14679 /* Called when a new struct TYPE is defined.
14680    If this structure or union completes the type of any previous
14681    variable declaration, lay it out and output its rtl.  */
14682
14683 void
14684 hack_incomplete_structures (type)
14685      tree type;
14686 {
14687   tree *list;
14688   struct binding_level *level;
14689
14690   if (!type) /* Don't do this for class templates.  */
14691     return;
14692
14693   if (namespace_bindings_p ())
14694     {
14695       level = 0;
14696       list = &namespace_scope_incomplete;
14697     }
14698   else
14699     {
14700       level = innermost_nonclass_level ();
14701       list = &level->incomplete;
14702     }
14703
14704   while (1)
14705     {
14706       while (*list)
14707         {
14708           tree decl = TREE_VALUE (*list);
14709           if ((decl && TREE_TYPE (decl) == type)
14710               || (TREE_TYPE (decl)
14711                   && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14712                   && TREE_TYPE (TREE_TYPE (decl)) == type))
14713             {
14714               int toplevel = toplevel_bindings_p ();
14715               if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14716                   && TREE_TYPE (TREE_TYPE (decl)) == type)
14717                 layout_type (TREE_TYPE (decl));
14718               layout_decl (decl, 0);
14719               rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
14720               if (! toplevel)
14721                 {
14722                   tree cleanup;
14723                   expand_decl (decl);
14724                   cleanup = maybe_build_cleanup (decl);
14725                   expand_decl_init (decl);
14726                   if (! expand_decl_cleanup (decl, cleanup))
14727                     cp_error ("parser lost in parsing declaration of `%D'",
14728                               decl);
14729                 }
14730               *list = TREE_CHAIN (*list);
14731             }
14732           else
14733             list = &TREE_CHAIN (*list);
14734         }
14735
14736       /* Keep looking through artificial binding levels generated
14737          for local variables.  */
14738       if (level && level->keep == 2)
14739         {
14740           level = level->level_chain;
14741           list = &level->incomplete;
14742         }
14743       else
14744         break;
14745     }
14746 }
14747
14748 /* If DECL is of a type which needs a cleanup, build that cleanup
14749    here.  */
14750
14751 tree
14752 maybe_build_cleanup (decl)
14753      tree decl;
14754 {
14755   tree type = TREE_TYPE (decl);
14756
14757   if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14758     {
14759       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14760       tree rval;
14761
14762       if (TREE_CODE (type) == ARRAY_TYPE)
14763         rval = decl;
14764       else
14765         {
14766           mark_addressable (decl);
14767           rval = build_unary_op (ADDR_EXPR, decl, 0);
14768         }
14769
14770       /* Optimize for space over speed here.  */
14771       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14772           || flag_expensive_optimizations)
14773         flags |= LOOKUP_NONVIRTUAL;
14774
14775       rval = build_delete (TREE_TYPE (rval), rval,
14776                            sfk_complete_destructor, flags, 0);
14777
14778       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14779           && ! TYPE_HAS_DESTRUCTOR (type))
14780         rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14781                                                build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14782
14783       return rval;
14784     }
14785   return 0;
14786 }
14787 \f
14788 /* Expand a C++ expression at the statement level.
14789    This is needed to ferret out nodes which have UNKNOWN_TYPE.
14790    The C++ type checker should get all of these out when
14791    expressions are combined with other, type-providing, expressions,
14792    leaving only orphan expressions, such as:
14793
14794    &class::bar;         / / takes its address, but does nothing with it.  */
14795
14796 void
14797 cplus_expand_expr_stmt (exp)
14798      tree exp;
14799 {
14800 #if 0
14801   /* We should do this eventually, but right now this causes regex.o from
14802      libg++ to miscompile, and tString to core dump.  */
14803   exp = build1 (CLEANUP_POINT_EXPR, TREE_TYPE (exp), exp);
14804 #endif
14805
14806   /* If we don't do this, we end up down inside expand_expr
14807      trying to do TYPE_MODE on the ERROR_MARK, and really
14808      go outside the bounds of the type.  */
14809   if (exp != error_mark_node)
14810     expand_expr_stmt (exp);
14811 }
14812
14813 /* When a stmt has been parsed, this function is called.  */
14814
14815 void
14816 finish_stmt ()
14817 {
14818   /* Always assume this statement was not an expression statement.  If
14819      it actually was an expression statement, its our callers
14820      responsibility to fix this up.  */
14821   last_expr_type = NULL_TREE;
14822 }
14823
14824 /* DECL was originally constructed as a non-static member function,
14825    but turned out to be static.  Update it accordingly.  */
14826
14827 void
14828 revert_static_member_fn (decl)
14829      tree decl;
14830 {
14831   tree tmp;
14832   tree function = TREE_TYPE (decl);
14833   tree args = TYPE_ARG_TYPES (function);
14834
14835   if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args)))
14836       != TYPE_UNQUALIFIED)
14837     cp_error ("static member function `%#D' declared with type qualifiers",
14838               *decl);
14839
14840   args = TREE_CHAIN (args);
14841   tmp = build_function_type (TREE_TYPE (function), args);
14842   tmp = build_qualified_type (tmp, CP_TYPE_QUALS (function));
14843   tmp = build_exception_variant (tmp,
14844                                  TYPE_RAISES_EXCEPTIONS (function));
14845   TREE_TYPE (decl) = tmp;
14846   if (DECL_ARGUMENTS (decl))
14847     DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
14848   DECL_STATIC_FUNCTION_P (decl) = 1;
14849 }
14850
14851 /* Initialize the variables used during compilation of a C++
14852    function.  */
14853
14854 static void
14855 push_cp_function_context (f)
14856      struct function *f;
14857 {
14858   struct language_function *p
14859     = ((struct language_function *)
14860        xcalloc (1, sizeof (struct language_function)));
14861   f->language = p;
14862
14863   /* It takes an explicit call to expand_body to generate RTL for a
14864      function.  */
14865   expanding_p = 0;
14866
14867   /* Whenever we start a new function, we destroy temporaries in the
14868      usual way.  */
14869   current_stmt_tree->stmts_are_full_exprs_p = 1;
14870 }
14871
14872 /* Free the language-specific parts of F, now that we've finished
14873    compiling the function.  */
14874
14875 static void
14876 pop_cp_function_context (f)
14877      struct function *f;
14878 {
14879   if (f->language)
14880     free (f->language);
14881   f->language = 0;
14882 }
14883
14884 /* Mark P for GC.  */
14885
14886 static void
14887 mark_lang_function (p)
14888      struct language_function *p;
14889 {
14890   if (!p)
14891     return;
14892
14893   ggc_mark_tree (p->x_ctor_label);
14894   ggc_mark_tree (p->x_dtor_label);
14895   ggc_mark_tree (p->x_current_class_ptr);
14896   ggc_mark_tree (p->x_current_class_ref);
14897   ggc_mark_tree (p->x_eh_spec_try_block);
14898   ggc_mark_tree (p->x_scope_stmt_stack);
14899
14900   ggc_mark_rtx (p->x_result_rtx);
14901
14902   mark_named_label_lists (&p->x_named_labels, &p->x_named_label_uses);
14903   mark_stmt_tree (&p->x_stmt_tree);
14904   mark_binding_level (&p->bindings);
14905 }
14906
14907 /* Mark the language-specific data in F for GC.  */
14908
14909 static void
14910 mark_cp_function_context (f)
14911      struct function *f;
14912 {
14913   mark_lang_function (f->language);
14914 }
14915
14916 void
14917 lang_mark_false_label_stack (l)
14918      struct label_node *l;
14919 {
14920   /* C++ doesn't use false_label_stack.  It better be NULL.  */
14921   my_friendly_assert (l == NULL, 19990904);
14922 }
14923
14924 void
14925 lang_mark_tree (t)
14926      tree t;
14927 {
14928   enum tree_code code = TREE_CODE (t);
14929   if (code == IDENTIFIER_NODE)
14930     {
14931       struct lang_identifier *li = (struct lang_identifier *) t;
14932       struct lang_id2 *li2 = li->x;
14933       ggc_mark_tree (li->namespace_bindings);
14934       ggc_mark_tree (li->bindings);
14935       ggc_mark_tree (li->class_value);
14936       ggc_mark_tree (li->class_template_info);
14937
14938       if (li2)
14939         {
14940           ggc_mark_tree (li2->label_value);
14941           ggc_mark_tree (li2->implicit_decl);
14942           ggc_mark_tree (li2->error_locus);
14943         }
14944     }
14945   else if (code == CPLUS_BINDING)
14946     {
14947       if (BINDING_HAS_LEVEL_P (t))
14948         mark_binding_level (&BINDING_LEVEL (t));
14949       else
14950         ggc_mark_tree (BINDING_SCOPE (t));
14951       ggc_mark_tree (BINDING_VALUE (t));
14952     }
14953   else if (code == OVERLOAD)
14954     ggc_mark_tree (OVL_FUNCTION (t));
14955   else if (code == TEMPLATE_PARM_INDEX)
14956     ggc_mark_tree (TEMPLATE_PARM_DECL (t));
14957   else if (TREE_CODE_CLASS (code) == 'd')
14958     {
14959       struct lang_decl *ld = DECL_LANG_SPECIFIC (t);
14960
14961       if (ld)
14962         {
14963           ggc_mark (ld);
14964           if (!DECL_GLOBAL_CTOR_P (t)
14965               && !DECL_GLOBAL_DTOR_P (t)
14966               && !DECL_THUNK_P (t))
14967             ggc_mark_tree (ld->decl_flags.u2.access);
14968           else if (DECL_THUNK_P (t))
14969             ggc_mark_tree (ld->decl_flags.u2.vcall_offset);
14970           ggc_mark_tree (ld->decl_flags.context);
14971           if (TREE_CODE (t) != NAMESPACE_DECL)
14972             ggc_mark_tree (ld->decl_flags.u.template_info);
14973           else
14974             mark_binding_level (&NAMESPACE_LEVEL (t));
14975           if (CAN_HAVE_FULL_LANG_DECL_P (t))
14976             {
14977               ggc_mark_tree (ld->befriending_classes);
14978               ggc_mark_tree (ld->saved_tree);
14979               ggc_mark_tree (ld->cloned_function);
14980               if (!DECL_OVERLOADED_OPERATOR_P (t))
14981                 ggc_mark_tree (ld->u2.vtt_parm);
14982               if (TREE_CODE (t) == TYPE_DECL)
14983                 ggc_mark_tree (ld->u.sorted_fields);
14984               else if (TREE_CODE (t) == FUNCTION_DECL
14985                        && !DECL_PENDING_INLINE_P (t))
14986                 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t));
14987             }
14988         }
14989     }
14990   else if (TREE_CODE_CLASS (code) == 't')
14991     {
14992       struct lang_type *lt = TYPE_LANG_SPECIFIC (t);
14993
14994       if (lt && !(TREE_CODE (t) == POINTER_TYPE
14995                   && TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE))
14996         {
14997           ggc_mark (lt);
14998           ggc_mark_tree (lt->vfields);
14999           ggc_mark_tree (lt->vbases);
15000           ggc_mark_tree (lt->tags);
15001           ggc_mark_tree (lt->size);
15002           ggc_mark_tree (lt->pure_virtuals);
15003           ggc_mark_tree (lt->friend_classes);
15004           ggc_mark_tree (lt->rtti);
15005           ggc_mark_tree (lt->methods);
15006           ggc_mark_tree (lt->template_info);
15007           ggc_mark_tree (lt->befriending_classes);
15008         }
15009       else if (lt)
15010         /* In the case of pointer-to-member function types, the
15011            TYPE_LANG_SPECIFIC is really just a tree.  */
15012         ggc_mark_tree ((tree) lt);
15013     }
15014 }