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           && DECL_NAME (link))
1446         {
1447           tree outer_binding
1448             = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1449           tree ns_binding;
1450
1451           if (!outer_binding)
1452             ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1453           else
1454             ns_binding = NULL_TREE;
1455
1456           if (outer_binding
1457               && (BINDING_LEVEL (outer_binding)
1458                   == current_binding_level->level_chain))
1459             /* We have something like:
1460
1461                  int i;
1462                  for (int i; ;);
1463
1464                and we are leaving the `for' scope.  There's no reason to
1465                keep the binding of the inner `i' in this case.  */
1466             pop_binding (DECL_NAME (link), link);
1467           else if ((outer_binding
1468                     && (TREE_CODE (BINDING_VALUE (outer_binding))
1469                         == TYPE_DECL))
1470                    || (ns_binding
1471                        && TREE_CODE (ns_binding) == TYPE_DECL))
1472             /* Here, we have something like:
1473
1474                  typedef int I;
1475
1476                  void f () {
1477                    for (int I; ;);
1478                  }
1479
1480                We must pop the for-scope binding so we know what's a
1481                type and what isn't.  */
1482             pop_binding (DECL_NAME (link), link);
1483           else
1484             {
1485               /* Mark this VAR_DECL as dead so that we can tell we left it
1486                  there only for backward compatibility.  */
1487               DECL_DEAD_FOR_LOCAL (link) = 1;
1488
1489               /* Keep track of what should of have happenned when we
1490                  popped the binding.  */
1491               if (outer_binding && BINDING_VALUE (outer_binding))
1492                 DECL_SHADOWED_FOR_VAR (link)
1493                   = BINDING_VALUE (outer_binding);
1494
1495               /* Add it to the list of dead variables in the next
1496                  outermost binding to that we can remove these when we
1497                  leave that binding.  */
1498               current_binding_level->level_chain->dead_vars_from_for
1499                 = tree_cons (NULL_TREE, link,
1500                              current_binding_level->level_chain->
1501                              dead_vars_from_for);
1502
1503               /* Although we don't pop the CPLUS_BINDING, we do clear
1504                  its BINDING_LEVEL since the level is going away now.  */
1505               BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1506                 = 0;
1507             }
1508         }
1509       else
1510         {
1511           /* Remove the binding.  */
1512           decl = link;
1513           if (TREE_CODE (decl) == TREE_LIST)
1514             decl = TREE_VALUE (decl);
1515           if (DECL_P (decl))
1516             pop_binding (DECL_NAME (decl), decl);
1517           else if (TREE_CODE (decl) == OVERLOAD)
1518             pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1519           else
1520             my_friendly_abort (0);
1521         }
1522     }
1523
1524   /* Remove declarations for any `for' variables from inner scopes
1525      that we kept around.  */
1526   for (link = current_binding_level->dead_vars_from_for;
1527        link; link = TREE_CHAIN (link))
1528     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1529
1530   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
1531   for (link = current_binding_level->type_shadowed;
1532        link; link = TREE_CHAIN (link))
1533     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1534
1535   /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
1536   for (link = current_binding_level->shadowed_labels;
1537        link;
1538        link = TREE_CHAIN (link))
1539     pop_label (TREE_VALUE (link), TREE_PURPOSE (link));
1540
1541   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1542      list if a `using' declaration put them there.  The debugging
1543      back-ends won't understand OVERLOAD, so we remove them here.
1544      Because the BLOCK_VARS are (temporarily) shared with
1545      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1546      popped all the bindings.  */
1547   if (block)
1548     {
1549       tree* d;
1550
1551       for (d = &BLOCK_VARS (block); *d; )
1552         {
1553           if (TREE_CODE (*d) == TREE_LIST)
1554             *d = TREE_CHAIN (*d);
1555           else
1556             d = &TREE_CHAIN (*d);
1557         }
1558     }
1559
1560   /* If the level being exited is the top level of a function,
1561      check over all the labels.  */
1562   if (functionbody)
1563     {
1564       /* Since this is the top level block of a function, the vars are
1565          the function's parameters.  Don't leave them in the BLOCK
1566          because they are found in the FUNCTION_DECL instead.  */
1567       BLOCK_VARS (block) = 0;
1568       pop_labels (block);
1569     }
1570
1571   tmp = current_binding_level->keep;
1572
1573   pop_binding_level ();
1574   if (functionbody)
1575     DECL_INITIAL (current_function_decl) = block;
1576   else if (block)
1577     {
1578       if (!block_previously_created)
1579         current_binding_level->blocks
1580           = chainon (current_binding_level->blocks, block);
1581     }
1582   /* If we did not make a block for the level just exited,
1583      any blocks made for inner levels
1584      (since they cannot be recorded as subblocks in that level)
1585      must be carried forward so they will later become subblocks
1586      of something else.  */
1587   else if (subblocks)
1588     current_binding_level->blocks
1589       = chainon (current_binding_level->blocks, subblocks);
1590
1591   /* Each and every BLOCK node created here in `poplevel' is important
1592      (e.g. for proper debugging information) so if we created one
1593      earlier, mark it as "used".  */
1594   if (block)
1595     TREE_USED (block) = 1;
1596
1597   /* Take care of compiler's internal binding structures.  */
1598   if (tmp == 2)
1599     {
1600       tree scope_stmts;
1601
1602       scope_stmts
1603         = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1604       if (block)
1605         {
1606           SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1607           SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1608         }
1609
1610       block = poplevel (keep, reverse, functionbody);
1611     }
1612
1613   return block;
1614 }
1615
1616 /* Delete the node BLOCK from the current binding level.
1617    This is used for the block inside a stmt expr ({...})
1618    so that the block can be reinserted where appropriate.  */
1619
1620 void
1621 delete_block (block)
1622      tree block;
1623 {
1624   tree t;
1625   if (current_binding_level->blocks == block)
1626     current_binding_level->blocks = TREE_CHAIN (block);
1627   for (t = current_binding_level->blocks; t;)
1628     {
1629       if (TREE_CHAIN (t) == block)
1630         TREE_CHAIN (t) = TREE_CHAIN (block);
1631       else
1632         t = TREE_CHAIN (t);
1633     }
1634   TREE_CHAIN (block) = NULL_TREE;
1635   /* Clear TREE_USED which is always set by poplevel.
1636      The flag is set again if insert_block is called.  */
1637   TREE_USED (block) = 0;
1638 }
1639
1640 /* Insert BLOCK at the end of the list of subblocks of the
1641    current binding level.  This is used when a BIND_EXPR is expanded,
1642    to handle the BLOCK node inside the BIND_EXPR.  */
1643
1644 void
1645 insert_block (block)
1646      tree block;
1647 {
1648   TREE_USED (block) = 1;
1649   current_binding_level->blocks
1650     = chainon (current_binding_level->blocks, block);
1651 }
1652
1653 /* Set the BLOCK node for the innermost scope
1654    (the one we are currently in).  */
1655
1656 void
1657 set_block (block)
1658     register tree block;
1659 {
1660   current_binding_level->this_block = block;
1661 }
1662
1663 /* Do a pushlevel for class declarations.  */
1664
1665 void
1666 pushlevel_class ()
1667 {
1668   register struct binding_level *newlevel;
1669
1670   /* Reuse or create a struct for this binding level.  */
1671 #if defined(DEBUG_CP_BINDING_LEVELS)
1672   if (0)
1673 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1674   if (free_binding_level)
1675 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1676     {
1677       newlevel = free_binding_level;
1678       free_binding_level = free_binding_level->level_chain;
1679     }
1680   else
1681     newlevel = make_binding_level ();
1682
1683 #if defined(DEBUG_CP_BINDING_LEVELS)
1684   is_class_level = 1;
1685 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1686
1687   push_binding_level (newlevel, 0, 0);
1688
1689   class_binding_level = current_binding_level;
1690   class_binding_level->parm_flag = 2;
1691   class_binding_level->this_class = current_class_type;
1692 }
1693
1694 /* ...and a poplevel for class declarations.  */
1695
1696 void
1697 poplevel_class ()
1698 {
1699   register struct binding_level *level = class_binding_level;
1700   tree shadowed;
1701
1702   my_friendly_assert (level != 0, 354);
1703
1704   /* If we're leaving a toplevel class, don't bother to do the setting
1705      of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1706      shouldn't even be used when current_class_type isn't set, and second,
1707      if we don't touch it here, we're able to use the cache effect if the
1708      next time we're entering a class scope, it is the same class.  */
1709   if (current_class_depth != 1)
1710     {
1711       struct binding_level* b;
1712
1713       /* Clear out our IDENTIFIER_CLASS_VALUEs.  */
1714       for (shadowed = level->class_shadowed;
1715            shadowed;
1716            shadowed = TREE_CHAIN (shadowed))
1717         IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1718
1719       /* Find the next enclosing class, and recreate
1720          IDENTIFIER_CLASS_VALUEs appropriate for that class.  */
1721       b = level->level_chain;
1722       while (b && b->parm_flag != 2)
1723         b = b->level_chain;
1724
1725       if (b)
1726         for (shadowed = b->class_shadowed;
1727              shadowed;
1728              shadowed = TREE_CHAIN (shadowed))
1729           {
1730             tree t;
1731
1732             t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1733             while (t && BINDING_LEVEL (t) != b)
1734               t = TREE_CHAIN (t);
1735
1736             if (t)
1737               IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1738                 = BINDING_VALUE (t);
1739           }
1740     }
1741   else
1742     /* Remember to save what IDENTIFIER's were bound in this scope so we
1743        can recover from cache misses.  */
1744     {
1745       previous_class_type = current_class_type;
1746       previous_class_values = class_binding_level->class_shadowed;
1747     }
1748   for (shadowed = level->type_shadowed;
1749        shadowed;
1750        shadowed = TREE_CHAIN (shadowed))
1751     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1752
1753   /* Remove the bindings for all of the class-level declarations.  */
1754   for (shadowed = level->class_shadowed;
1755        shadowed;
1756        shadowed = TREE_CHAIN (shadowed))
1757     pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1758
1759   GNU_xref_end_scope ((HOST_WIDE_INT) class_binding_level,
1760                       (HOST_WIDE_INT) class_binding_level->level_chain,
1761                       class_binding_level->parm_flag,
1762                       class_binding_level->keep);
1763
1764   /* Now, pop out of the binding level which we created up in the
1765      `pushlevel_class' routine.  */
1766 #if defined(DEBUG_CP_BINDING_LEVELS)
1767   is_class_level = 1;
1768 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1769
1770   pop_binding_level ();
1771 }
1772
1773 /* We are entering the scope of a class.  Clear IDENTIFIER_CLASS_VALUE
1774    for any names in enclosing classes.  */
1775
1776 void
1777 clear_identifier_class_values ()
1778 {
1779   tree t;
1780
1781   if (!class_binding_level)
1782     return;
1783
1784   for (t = class_binding_level->class_shadowed;
1785        t;
1786        t = TREE_CHAIN (t))
1787     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1788 }
1789
1790 /* Returns non-zero if T is a virtual function table.  */
1791
1792 int
1793 vtable_decl_p (t, data)
1794      tree t;
1795      void *data ATTRIBUTE_UNUSED;
1796 {
1797   return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1798 }
1799
1800 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1801    functions.  */
1802
1803 int
1804 vtype_decl_p (t, data)
1805      tree t;
1806      void *data ATTRIBUTE_UNUSED;
1807 {
1808   return (TREE_CODE (t) == TYPE_DECL
1809           && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE
1810           && TYPE_POLYMORPHIC_P (TREE_TYPE (t)));
1811 }
1812
1813 /* Return the declarations that are members of the namespace NS.  */
1814
1815 tree
1816 cp_namespace_decls (ns)
1817      tree ns;
1818 {
1819   return NAMESPACE_LEVEL (ns)->names;
1820 }
1821
1822 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1823    itself, calling F for each.  The DATA is passed to F as well.  */
1824
1825 static int
1826 walk_namespaces_r (namespace, f, data)
1827      tree namespace;
1828      walk_namespaces_fn f;
1829      void *data;
1830 {
1831   tree current;
1832   int result = 0;
1833
1834   result |= (*f) (namespace, data);
1835
1836   for (current = cp_namespace_decls (namespace);
1837        current;
1838        current = TREE_CHAIN (current))
1839     {
1840       if (TREE_CODE (current) != NAMESPACE_DECL
1841           || DECL_NAMESPACE_ALIAS (current))
1842         continue;
1843       if (!DECL_LANG_SPECIFIC (current))
1844         {
1845           /* Hmm. std. */
1846           my_friendly_assert (current == std_node, 393);
1847           continue;
1848         }
1849
1850       /* We found a namespace.  */
1851       result |= walk_namespaces_r (current, f, data);
1852     }
1853
1854   return result;
1855 }
1856
1857 /* Walk all the namespaces, calling F for each.  The DATA is passed to
1858    F as well.  */
1859
1860 int
1861 walk_namespaces (f, data)
1862      walk_namespaces_fn f;
1863      void *data;
1864 {
1865   return walk_namespaces_r (global_namespace, f, data);
1866 }
1867
1868 struct walk_globals_data {
1869   walk_globals_pred p;
1870   walk_globals_fn f;
1871   void *data;
1872 };
1873
1874 /* Walk the global declarations in NAMESPACE.  Whenever one is found
1875    for which P returns non-zero, call F with its address.  If any call
1876    to F returns a non-zero value, return a non-zero value.  */
1877
1878 static int
1879 walk_globals_r (namespace, data)
1880      tree namespace;
1881      void *data;
1882 {
1883   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1884   walk_globals_pred p = wgd->p;
1885   walk_globals_fn f = wgd->f;
1886   void *d = wgd->data;
1887   tree *t;
1888   int result = 0;
1889
1890   t = &NAMESPACE_LEVEL (namespace)->names;
1891
1892   while (*t)
1893     {
1894       tree glbl = *t;
1895
1896       if ((*p) (glbl, d))
1897         result |= (*f) (t, d);
1898
1899       /* If F changed *T, then *T still points at the next item to
1900          examine.  */
1901       if (*t == glbl)
1902         t = &TREE_CHAIN (*t);
1903     }
1904
1905   return result;
1906 }
1907
1908 /* Walk the global declarations.  Whenever one is found for which P
1909    returns non-zero, call F with its address.  If any call to F
1910    returns a non-zero value, return a non-zero value.  */
1911
1912 int
1913 walk_globals (p, f, data)
1914      walk_globals_pred p;
1915      walk_globals_fn f;
1916      void *data;
1917 {
1918   struct walk_globals_data wgd;
1919   wgd.p = p;
1920   wgd.f = f;
1921   wgd.data = data;
1922
1923   return walk_namespaces (walk_globals_r, &wgd);
1924 }
1925
1926 /* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
1927    DATA is non-NULL, this is the last time we will call
1928    wrapup_global_declarations for this NAMESPACE.  */
1929
1930 int
1931 wrapup_globals_for_namespace (namespace, data)
1932      tree namespace;
1933      void *data;
1934 {
1935   tree globals = cp_namespace_decls (namespace);
1936   int len = list_length (globals);
1937   tree *vec = (tree *) alloca (sizeof (tree) * len);
1938   int i;
1939   int result;
1940   tree decl;
1941   int last_time = (data != 0);
1942
1943   if (last_time && namespace == global_namespace)
1944     /* Let compile_file handle the global namespace.  */
1945     return 0;
1946
1947   /* Process the decls in reverse order--earliest first.
1948      Put them into VEC from back to front, then take out from front.  */
1949
1950   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1951     {
1952       /* Pretend we've output an unused static variable.  This ensures
1953          that the toplevel __FUNCTION__ etc won't be emitted, unless
1954          needed. */
1955       if (TREE_CODE (decl) == VAR_DECL && DECL_ARTIFICIAL (decl)
1956           && !TREE_PUBLIC (decl) && !TREE_USED (decl))
1957         {
1958           TREE_ASM_WRITTEN (decl) = 1;
1959           DECL_IGNORED_P (decl) = 1;
1960         }
1961       vec[len - i - 1] = decl;
1962     }
1963
1964   if (last_time)
1965     {
1966       check_global_declarations (vec, len);
1967       return 0;
1968     }
1969
1970   /* Temporarily mark vtables as external.  That prevents
1971      wrapup_global_declarations from writing them out; we must process
1972      them ourselves in finish_vtable_vardecl.  */
1973   for (i = 0; i < len; ++i)
1974     if (vtable_decl_p (vec[i], /*data=*/0) && !DECL_EXTERNAL (vec[i]))
1975       {
1976         DECL_NOT_REALLY_EXTERN (vec[i]) = 1;
1977         DECL_EXTERNAL (vec[i]) = 1;
1978       }
1979
1980   /* Write out any globals that need to be output.  */
1981   result = wrapup_global_declarations (vec, len);
1982
1983   /* Undo the hack to DECL_EXTERNAL above.  */
1984   for (i = 0; i < len; ++i)
1985     if (vtable_decl_p (vec[i], /*data=*/0)
1986         && DECL_NOT_REALLY_EXTERN (vec[i]))
1987       {
1988         DECL_NOT_REALLY_EXTERN (vec[i]) = 0;
1989         DECL_EXTERNAL (vec[i]) = 0;
1990       }
1991
1992   return result;
1993 }
1994
1995 \f
1996 /* Mark ARG (which is really a struct binding_level **) for GC.  */
1997
1998 static void
1999 mark_binding_level (arg)
2000      void *arg;
2001 {
2002   struct binding_level *lvl = *(struct binding_level **)arg;
2003
2004   for (; lvl; lvl = lvl->level_chain)
2005     {
2006       ggc_mark_tree (lvl->names);
2007       ggc_mark_tree (lvl->tags);
2008       ggc_mark_tree (lvl->usings);
2009       ggc_mark_tree (lvl->using_directives);
2010       ggc_mark_tree (lvl->class_shadowed);
2011       ggc_mark_tree (lvl->type_shadowed);
2012       ggc_mark_tree (lvl->shadowed_labels);
2013       ggc_mark_tree (lvl->blocks);
2014       ggc_mark_tree (lvl->this_block);
2015       ggc_mark_tree (lvl->this_class);
2016       ggc_mark_tree (lvl->incomplete);
2017       ggc_mark_tree (lvl->dead_vars_from_for);
2018     }
2019 }
2020
2021 static void
2022 mark_named_label_lists (labs, uses)
2023      void *labs;
2024      void *uses;
2025 {
2026   struct named_label_list *l = *(struct named_label_list **)labs;
2027   struct named_label_use_list *u = *(struct named_label_use_list **)uses;
2028
2029   for (; l; l = l->next)
2030     {
2031       ggc_mark (l);
2032       mark_binding_level (l->binding_level);
2033       ggc_mark_tree (l->old_value);
2034       ggc_mark_tree (l->label_decl);
2035       ggc_mark_tree (l->bad_decls);
2036     }
2037
2038   for (; u; u = u->next)
2039     ggc_mark (u);
2040 }
2041 \f
2042 /* For debugging.  */
2043 static int no_print_functions = 0;
2044 static int no_print_builtins = 0;
2045
2046 void
2047 print_binding_level (lvl)
2048      struct binding_level *lvl;
2049 {
2050   tree t;
2051   int i = 0, len;
2052   fprintf (stderr, " blocks=");
2053   fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
2054   fprintf (stderr, " n_incomplete=%d parm_flag=%d keep=%d",
2055            list_length (lvl->incomplete), lvl->parm_flag, lvl->keep);
2056   if (lvl->tag_transparent)
2057     fprintf (stderr, " tag-transparent");
2058   if (lvl->more_cleanups_ok)
2059     fprintf (stderr, " more-cleanups-ok");
2060   if (lvl->have_cleanups)
2061     fprintf (stderr, " have-cleanups");
2062   fprintf (stderr, "\n");
2063   if (lvl->names)
2064     {
2065       fprintf (stderr, " names:\t");
2066       /* We can probably fit 3 names to a line?  */
2067       for (t = lvl->names; t; t = TREE_CHAIN (t))
2068         {
2069           if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
2070             continue;
2071           if (no_print_builtins
2072               && (TREE_CODE (t) == TYPE_DECL)
2073               && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
2074             continue;
2075
2076           /* Function decls tend to have longer names.  */
2077           if (TREE_CODE (t) == FUNCTION_DECL)
2078             len = 3;
2079           else
2080             len = 2;
2081           i += len;
2082           if (i > 6)
2083             {
2084               fprintf (stderr, "\n\t");
2085               i = len;
2086             }
2087           print_node_brief (stderr, "", t, 0);
2088           if (t == error_mark_node)
2089             break;
2090         }
2091       if (i)
2092         fprintf (stderr, "\n");
2093     }
2094   if (lvl->tags)
2095     {
2096       fprintf (stderr, " tags:\t");
2097       i = 0;
2098       for (t = lvl->tags; t; t = TREE_CHAIN (t))
2099         {
2100           if (TREE_PURPOSE (t) == NULL_TREE)
2101             len = 3;
2102           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2103             len = 2;
2104           else
2105             len = 4;
2106           i += len;
2107           if (i > 5)
2108             {
2109               fprintf (stderr, "\n\t");
2110               i = len;
2111             }
2112           if (TREE_PURPOSE (t) == NULL_TREE)
2113             {
2114               print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
2115               fprintf (stderr, ">");
2116             }
2117           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2118             print_node_brief (stderr, "", TREE_VALUE (t), 0);
2119           else
2120             {
2121               print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
2122               print_node_brief (stderr, "", TREE_VALUE (t), 0);
2123               fprintf (stderr, ">");
2124             }
2125         }
2126       if (i)
2127         fprintf (stderr, "\n");
2128     }
2129   if (lvl->class_shadowed)
2130     {
2131       fprintf (stderr, " class-shadowed:");
2132       for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
2133         {
2134           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2135         }
2136       fprintf (stderr, "\n");
2137     }
2138   if (lvl->type_shadowed)
2139     {
2140       fprintf (stderr, " type-shadowed:");
2141       for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
2142         {
2143           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2144         }
2145       fprintf (stderr, "\n");
2146     }
2147 }
2148
2149 void
2150 print_other_binding_stack (stack)
2151      struct binding_level *stack;
2152 {
2153   struct binding_level *level;
2154   for (level = stack; level != global_binding_level; level = level->level_chain)
2155     {
2156       fprintf (stderr, "binding level ");
2157       fprintf (stderr, HOST_PTR_PRINTF, level);
2158       fprintf (stderr, "\n");
2159       print_binding_level (level);
2160     }
2161 }
2162
2163 void
2164 print_binding_stack ()
2165 {
2166   struct binding_level *b;
2167   fprintf (stderr, "current_binding_level=");
2168   fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
2169   fprintf (stderr, "\nclass_binding_level=");
2170   fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
2171   fprintf (stderr, "\nglobal_binding_level=");
2172   fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
2173   fprintf (stderr, "\n");
2174   if (class_binding_level)
2175     {
2176       for (b = class_binding_level; b; b = b->level_chain)
2177         if (b == current_binding_level)
2178           break;
2179       if (b)
2180         b = class_binding_level;
2181       else
2182         b = current_binding_level;
2183     }
2184   else
2185     b = current_binding_level;
2186   print_other_binding_stack (b);
2187   fprintf (stderr, "global:\n");
2188   print_binding_level (global_binding_level);
2189 }
2190
2191 /* Namespace binding access routines: The namespace_bindings field of
2192    the identifier is polymorphic, with three possible values:
2193    NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2194    indicating the BINDING_VALUE of global_namespace. */
2195
2196 /* Check whether the a binding for the name to scope is known.
2197    Assumes that the bindings of the name are already a list
2198    of bindings. Returns the binding found, or NULL_TREE. */
2199
2200 static tree
2201 find_binding (name, scope)
2202      tree name;
2203      tree scope;
2204 {
2205   tree iter, prev = NULL_TREE;
2206
2207   scope = ORIGINAL_NAMESPACE (scope);
2208
2209   for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2210        iter = TREE_CHAIN (iter))
2211     {
2212       my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2213       if (BINDING_SCOPE (iter) == scope)
2214         {
2215           /* Move binding found to the front of the list, so
2216              subsequent lookups will find it faster. */
2217           if (prev)
2218             {
2219               TREE_CHAIN (prev) = TREE_CHAIN (iter);
2220               TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2221               IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2222             }
2223           return iter;
2224         }
2225       prev = iter;
2226     }
2227   return NULL_TREE;
2228 }
2229
2230 /* Always returns a binding for name in scope. If the
2231    namespace_bindings is not a list, convert it to one first.
2232    If no binding is found, make a new one. */
2233
2234 tree
2235 binding_for_name (name, scope)
2236      tree name;
2237      tree scope;
2238 {
2239   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2240   tree result;
2241
2242   scope = ORIGINAL_NAMESPACE (scope);
2243
2244   if (b && TREE_CODE (b) != CPLUS_BINDING)
2245     {
2246       /* Get rid of optimization for global scope. */
2247       IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2248       BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2249       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2250     }
2251   if (b && (result = find_binding (name, scope)))
2252     return result;
2253   /* Not found, make a new one. */
2254   result = make_node (CPLUS_BINDING);
2255   TREE_CHAIN (result) = b;
2256   IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2257   BINDING_SCOPE (result) = scope;
2258   BINDING_TYPE (result) = NULL_TREE;
2259   BINDING_VALUE (result) = NULL_TREE;
2260   return result;
2261 }
2262
2263 /* Return the binding value for name in scope, considering that
2264    namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2265
2266 tree
2267 namespace_binding (name, scope)
2268      tree name;
2269      tree scope;
2270 {
2271   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2272   if (b == NULL_TREE)
2273     return NULL_TREE;
2274   if (scope == NULL_TREE)
2275     scope = global_namespace;
2276   if (TREE_CODE (b) != CPLUS_BINDING)
2277     return (scope == global_namespace) ? b : NULL_TREE;
2278   name = find_binding (name,scope);
2279   if (name == NULL_TREE)
2280     return name;
2281   return BINDING_VALUE (name);
2282 }
2283
2284 /* Set the binding value for name in scope. If modifying the binding
2285    of global_namespace is attempted, try to optimize it. */
2286
2287 void
2288 set_namespace_binding (name, scope, val)
2289      tree name;
2290      tree scope;
2291      tree val;
2292 {
2293   tree b;
2294
2295   if (scope == NULL_TREE)
2296     scope = global_namespace;
2297
2298   if (scope == global_namespace)
2299     {
2300       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2301       if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2302         {
2303           IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2304           return;
2305         }
2306     }
2307   b = binding_for_name (name, scope);
2308   BINDING_VALUE (b) = val;
2309 }
2310
2311 /* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
2312    select a name that is unique to this compilation unit.  */
2313
2314 void
2315 push_namespace (name)
2316      tree name;
2317 {
2318   tree d = NULL_TREE;
2319   int need_new = 1;
2320   int implicit_use = 0;
2321   int global = 0;
2322   if (!global_namespace)
2323     {
2324       /* This must be ::. */
2325       my_friendly_assert (name == get_identifier ("::"), 377);
2326       global = 1;
2327     }
2328   else if (!name)
2329     {
2330       /* The name of anonymous namespace is unique for the translation
2331          unit.  */
2332       if (!anonymous_namespace_name)
2333         anonymous_namespace_name = get_file_function_name ('N');
2334       name = anonymous_namespace_name;
2335       d = IDENTIFIER_NAMESPACE_VALUE (name);
2336       if (d)
2337         /* Reopening anonymous namespace.  */
2338         need_new = 0;
2339       implicit_use = 1;
2340     }
2341   else if (current_namespace == global_namespace
2342            && name == DECL_NAME (std_node))
2343     {
2344       in_std++;
2345       return;
2346     }
2347   else
2348     {
2349       /* Check whether this is an extended namespace definition. */
2350       d = IDENTIFIER_NAMESPACE_VALUE (name);
2351       if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2352         {
2353           need_new = 0;
2354           if (DECL_NAMESPACE_ALIAS (d))
2355             {
2356               cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
2357                         d, DECL_NAMESPACE_ALIAS (d));
2358               d = DECL_NAMESPACE_ALIAS (d);
2359             }
2360         }
2361     }
2362
2363   if (need_new)
2364     {
2365       /* Make a new namespace, binding the name to it. */
2366       d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2367       /* The global namespace is not pushed, and the global binding
2368          level is set elsewhere.  */
2369       if (!global)
2370         {
2371           DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
2372           d = pushdecl (d);
2373           pushlevel (0);
2374           declare_namespace_level ();
2375           NAMESPACE_LEVEL (d) = current_binding_level;
2376         }
2377     }
2378   else
2379     resume_binding_level (NAMESPACE_LEVEL (d));
2380
2381   if (implicit_use)
2382     do_using_directive (d);
2383   /* Enter the name space. */
2384   current_namespace = d;
2385 }
2386
2387 /* Pop from the scope of the current namespace.  */
2388
2389 void
2390 pop_namespace ()
2391 {
2392   if (current_namespace == global_namespace)
2393     {
2394       my_friendly_assert (in_std>0, 980421);
2395       in_std--;
2396       return;
2397     }
2398   current_namespace = CP_DECL_CONTEXT (current_namespace);
2399   /* The binding level is not popped, as it might be re-opened later.  */
2400   suspend_binding_level ();
2401 }
2402
2403 /* Push into the scope of the namespace NS, even if it is deeply
2404    nested within another namespace.  */
2405
2406 void
2407 push_nested_namespace (ns)
2408      tree ns;
2409 {
2410   if (ns == global_namespace)
2411     push_to_top_level ();
2412   else
2413     {
2414       push_nested_namespace (CP_DECL_CONTEXT (ns));
2415       push_namespace (DECL_NAME (ns));
2416     }
2417 }
2418
2419 /* Pop back from the scope of the namespace NS, which was previously
2420    entered with push_nested_namespace.  */
2421
2422 void
2423 pop_nested_namespace (ns)
2424      tree ns;
2425 {
2426   while (ns != global_namespace)
2427     {
2428       pop_namespace ();
2429       ns = CP_DECL_CONTEXT (ns);
2430     }
2431
2432   pop_from_top_level ();
2433 }
2434
2435 \f
2436 /* Subroutines for reverting temporarily to top-level for instantiation
2437    of templates and such.  We actually need to clear out the class- and
2438    local-value slots of all identifiers, so that only the global values
2439    are at all visible.  Simply setting current_binding_level to the global
2440    scope isn't enough, because more binding levels may be pushed.  */
2441 struct saved_scope *scope_chain;
2442
2443 /* Mark ST for GC.  */
2444
2445 static void
2446 mark_stmt_tree (st)
2447      struct stmt_tree *st;
2448 {
2449   ggc_mark_tree (st->x_last_stmt);
2450   ggc_mark_tree (st->x_last_expr_type);
2451 }
2452
2453 /* Mark ARG (which is really a struct saved_scope **) for GC.  */
2454
2455 static void
2456 mark_saved_scope (arg)
2457      void *arg;
2458 {
2459   struct saved_scope *t = *(struct saved_scope **)arg;
2460   while (t)
2461     {
2462       mark_binding_level (&t->class_bindings);
2463       ggc_mark_tree (t->old_bindings);
2464       ggc_mark_tree (t->old_namespace);
2465       ggc_mark_tree (t->class_name);
2466       ggc_mark_tree (t->class_type);
2467       ggc_mark_tree (t->access_specifier);
2468       ggc_mark_tree (t->function_decl);
2469       if (t->lang_base)
2470         ggc_mark_tree_varray (t->lang_base);
2471       ggc_mark_tree (t->lang_name);
2472       ggc_mark_tree (t->x_function_parms);
2473       ggc_mark_tree (t->template_parms);
2474       ggc_mark_tree (t->x_previous_class_type);
2475       ggc_mark_tree (t->x_previous_class_values);
2476       ggc_mark_tree (t->x_saved_tree);
2477       ggc_mark_tree (t->incomplete);
2478       ggc_mark_tree (t->lookups);
2479
2480       mark_stmt_tree (&t->x_stmt_tree);
2481       mark_binding_level (&t->bindings);
2482       t = t->prev;
2483     }
2484 }
2485
2486 static tree
2487 store_bindings (names, old_bindings)
2488      tree names, old_bindings;
2489 {
2490   tree t;
2491   for (t = names; t; t = TREE_CHAIN (t))
2492     {
2493       tree binding, t1, id;
2494
2495       if (TREE_CODE (t) == TREE_LIST)
2496         id = TREE_PURPOSE (t);
2497       else
2498         id = DECL_NAME (t);
2499
2500       if (!id
2501           /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2502              we have no IDENTIFIER_BINDING if we have left the class
2503              scope, but cached the class-level declarations.  */
2504           || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2505         continue;
2506
2507       for (t1 = old_bindings; t1; t1 = TREE_CHAIN (t1))
2508         if (TREE_VEC_ELT (t1, 0) == id)
2509           goto skip_it;
2510
2511       binding = make_tree_vec (4);
2512
2513       if (id)
2514         {
2515           my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2516           TREE_VEC_ELT (binding, 0) = id;
2517           TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2518           TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2519           TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2520           IDENTIFIER_BINDING (id) = NULL_TREE;
2521           IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2522         }
2523       TREE_CHAIN (binding) = old_bindings;
2524       old_bindings = binding;
2525     skip_it:
2526       ;
2527     }
2528   return old_bindings;
2529 }
2530
2531 void
2532 maybe_push_to_top_level (pseudo)
2533      int pseudo;
2534 {
2535   struct saved_scope *s;
2536   struct binding_level *b;
2537   tree old_bindings;
2538   int need_pop;
2539
2540   s = (struct saved_scope *) xcalloc (1, sizeof (struct saved_scope));
2541
2542   b = scope_chain ? current_binding_level : 0;
2543
2544   /* If we're in the middle of some function, save our state.  */
2545   if (cfun)
2546     {
2547       need_pop = 1;
2548       push_function_context_to (NULL_TREE);
2549     }
2550   else
2551     need_pop = 0;
2552
2553   old_bindings = NULL_TREE;
2554   if (scope_chain && previous_class_type)
2555     old_bindings = store_bindings (previous_class_values, old_bindings);
2556
2557   /* Have to include global_binding_level, because class-level decls
2558      aren't listed anywhere useful.  */
2559   for (; b; b = b->level_chain)
2560     {
2561       tree t;
2562
2563       /* Template IDs are inserted into the global level. If they were
2564          inserted into namespace level, finish_file wouldn't find them
2565          when doing pending instantiations. Therefore, don't stop at
2566          namespace level, but continue until :: .  */
2567       if (b == global_binding_level || (pseudo && b->template_parms_p))
2568         break;
2569
2570       old_bindings = store_bindings (b->names, old_bindings);
2571       /* We also need to check class_shadowed to save class-level type
2572          bindings, since pushclass doesn't fill in b->names.  */
2573       if (b->parm_flag == 2)
2574         old_bindings = store_bindings (b->class_shadowed, old_bindings);
2575
2576       /* Unwind type-value slots back to top level.  */
2577       for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2578         SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2579     }
2580   s->prev = scope_chain;
2581   s->old_bindings = old_bindings;
2582   s->bindings = b;
2583   s->need_pop_function_context = need_pop;
2584   s->function_decl = current_function_decl;
2585
2586   scope_chain = s;
2587   current_function_decl = NULL_TREE;
2588   VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2589   current_lang_stack = &VARRAY_TREE (current_lang_base, 0);
2590   current_lang_name = lang_name_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 we were in the middle of compiling a function, restore our
2625      state.  */
2626   if (s->need_pop_function_context)
2627     pop_function_context_from (NULL_TREE);
2628   current_function_decl = s->function_decl;
2629
2630   free (s);
2631 }
2632 \f
2633 /* Push a definition of struct, union or enum tag "name".
2634    into binding_level "b".   "type" should be the type node,
2635    We assume that the tag "name" is not already defined.
2636
2637    Note that the definition may really be just a forward reference.
2638    In that case, the TYPE_SIZE will be a NULL_TREE.
2639
2640    C++ gratuitously puts all these tags in the name space.  */
2641
2642 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2643    record the shadowed value for this binding contour.  TYPE is
2644    the type that ID maps to.  */
2645
2646 static void
2647 set_identifier_type_value_with_scope (id, type, b)
2648      tree id;
2649      tree type;
2650      struct binding_level *b;
2651 {
2652   if (!b->namespace_p)
2653     {
2654       /* Shadow the marker, not the real thing, so that the marker
2655          gets restored later. */
2656       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2657       b->type_shadowed
2658         = tree_cons (id, old_type_value, b->type_shadowed);
2659     }
2660   else
2661     {
2662       tree binding = binding_for_name (id, current_namespace);
2663       BINDING_TYPE (binding) = type;
2664       /* Store marker instead of real type. */
2665       type = global_type_node;
2666     }
2667   SET_IDENTIFIER_TYPE_VALUE (id, type);
2668 }
2669
2670 /* As set_identifier_type_value_with_scope, but using current_binding_level.  */
2671
2672 void
2673 set_identifier_type_value (id, type)
2674      tree id;
2675      tree type;
2676 {
2677   set_identifier_type_value_with_scope (id, type, current_binding_level);
2678 }
2679
2680 /* Return the type associated with id. */
2681
2682 tree
2683 identifier_type_value (id)
2684      tree id;
2685 {
2686   /* There is no type with that name, anywhere. */
2687   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2688     return NULL_TREE;
2689   /* This is not the type marker, but the real thing. */
2690   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2691     return REAL_IDENTIFIER_TYPE_VALUE (id);
2692   /* Have to search for it. It must be on the global level, now.
2693      Ask lookup_name not to return non-types. */
2694   id = lookup_name_real (id, 2, 1, 0);
2695   if (id)
2696     return TREE_TYPE (id);
2697   return NULL_TREE;
2698 }
2699
2700 /* Pop off extraneous binding levels left over due to syntax errors.
2701
2702    We don't pop past namespaces, as they might be valid.  */
2703
2704 void
2705 pop_everything ()
2706 {
2707 #ifdef DEBUG_CP_BINDING_LEVELS
2708   fprintf (stderr, "XXX entering pop_everything ()\n");
2709 #endif
2710   while (!toplevel_bindings_p ())
2711     {
2712       if (current_binding_level->parm_flag == 2)
2713         pop_nested_class ();
2714       else
2715         poplevel (0, 0, 0);
2716     }
2717 #ifdef DEBUG_CP_BINDING_LEVELS
2718   fprintf (stderr, "XXX leaving pop_everything ()\n");
2719 #endif
2720 }
2721
2722 /* The type TYPE is being declared.  If it is a class template, or a
2723    specialization of a class template, do any processing required and
2724    perform error-checking.  If IS_FRIEND is non-zero, this TYPE is
2725    being declared a friend.  B is the binding level at which this TYPE
2726    should be bound.
2727
2728    Returns the TYPE_DECL for TYPE, which may have been altered by this
2729    processing.  */
2730
2731 static tree
2732 maybe_process_template_type_declaration (type, globalize, b)
2733      tree type;
2734      int globalize;
2735      struct binding_level* b;
2736 {
2737   tree decl = TYPE_NAME (type);
2738
2739   if (processing_template_parmlist)
2740     /* You can't declare a new template type in a template parameter
2741        list.  But, you can declare a non-template type:
2742
2743          template <class A*> struct S;
2744
2745        is a forward-declaration of `A'.  */
2746     ;
2747   else
2748     {
2749       maybe_check_template_type (type);
2750
2751       my_friendly_assert (IS_AGGR_TYPE (type)
2752                           || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2753
2754
2755       if (processing_template_decl)
2756         {
2757           /* This may change after the call to
2758              push_template_decl_real, but we want the original value.  */
2759           tree name = DECL_NAME (decl);
2760
2761           decl = push_template_decl_real (decl, globalize);
2762           /* If the current binding level is the binding level for the
2763              template parameters (see the comment in
2764              begin_template_parm_list) and the enclosing level is a class
2765              scope, and we're not looking at a friend, push the
2766              declaration of the member class into the class scope.  In the
2767              friend case, push_template_decl will already have put the
2768              friend into global scope, if appropriate.  */
2769           if (TREE_CODE (type) != ENUMERAL_TYPE
2770               && !globalize && b->template_parms_p
2771               && b->level_chain->parm_flag == 2)
2772             {
2773               finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2774               /* Put this tag on the list of tags for the class, since
2775                  that won't happen below because B is not the class
2776                  binding level, but is instead the pseudo-global level.  */
2777               b->level_chain->tags =
2778                 tree_cons (name, type, b->level_chain->tags);
2779               if (!COMPLETE_TYPE_P (current_class_type))
2780                 CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2781             }
2782         }
2783     }
2784
2785   return decl;
2786 }
2787
2788 /* In C++, you don't have to write `struct S' to refer to `S'; you
2789    can just use `S'.  We accomplish this by creating a TYPE_DECL as
2790    if the user had written `typedef struct S S'.  Create and return
2791    the TYPE_DECL for TYPE.  */
2792
2793 tree
2794 create_implicit_typedef (name, type)
2795      tree name;
2796      tree type;
2797 {
2798   tree decl;
2799
2800   decl = build_decl (TYPE_DECL, name, type);
2801   DECL_ARTIFICIAL (decl) = 1;
2802   /* There are other implicit type declarations, like the one *within*
2803      a class that allows you to write `S::S'.  We must distinguish
2804      amongst these.  */
2805   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2806   TYPE_NAME (type) = decl;
2807
2808   return decl;
2809 }
2810
2811 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2812    Normally put it into the inner-most non-tag-transparent scope,
2813    but if GLOBALIZE is true, put it in the inner-most non-class scope.
2814    The latter is needed for implicit declarations.  */
2815
2816 void
2817 pushtag (name, type, globalize)
2818      tree name, type;
2819      int globalize;
2820 {
2821   register struct binding_level *b;
2822
2823   b = current_binding_level;
2824   while (b->tag_transparent
2825          || (globalize && b->parm_flag == 2))
2826     b = b->level_chain;
2827
2828   b->tags = tree_cons (name, type, b->tags);
2829
2830   if (name)
2831     {
2832       /* Do C++ gratuitous typedefing.  */
2833       if (IDENTIFIER_TYPE_VALUE (name) != type)
2834         {
2835           register tree d = NULL_TREE;
2836           int in_class = 0;
2837           tree context = TYPE_CONTEXT (type);
2838
2839           if (! context)
2840             {
2841               tree cs = current_scope ();
2842
2843               if (! globalize)
2844                 context = cs;
2845               else if (cs != NULL_TREE && TYPE_P (cs))
2846                 /* When declaring a friend class of a local class, we want
2847                    to inject the newly named class into the scope
2848                    containing the local class, not the namespace scope.  */
2849                 context = decl_function_context (get_type_decl (cs));
2850             }
2851           if (!context)
2852             context = current_namespace;
2853
2854           if ((b->template_parms_p && b->level_chain->parm_flag == 2)
2855               || b->parm_flag == 2)
2856             in_class = 1;
2857
2858           if (current_lang_name == lang_name_java)
2859             TYPE_FOR_JAVA (type) = 1;
2860
2861           d = create_implicit_typedef (name, type);
2862           DECL_CONTEXT (d) = FROB_CONTEXT (context);
2863           if (! in_class)
2864             set_identifier_type_value_with_scope (name, type, b);
2865
2866           d = maybe_process_template_type_declaration (type,
2867                                                        globalize, b);
2868
2869           if (b->parm_flag == 2)
2870             {
2871               if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2872                 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2873                    class.  But if it's a member template class, we
2874                    want the TEMPLATE_DECL, not the TYPE_DECL, so this
2875                    is done later.  */
2876                 finish_member_declaration (d);
2877               else
2878                 pushdecl_class_level (d);
2879             }
2880           else
2881             d = pushdecl_with_scope (d, b);
2882
2883           if (ANON_AGGRNAME_P (name))
2884             DECL_IGNORED_P (d) = 1;
2885
2886           TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2887           DECL_ASSEMBLER_NAME (d) = DECL_NAME (d);
2888
2889           /* If this is a local class, keep track of it.  We need this
2890              information for name-mangling, and so that it is possible to find
2891              all function definitions in a translation unit in a convenient
2892              way.  (It's otherwise tricky to find a member function definition
2893              it's only pointed to from within a local class.)  */
2894           if (TYPE_CONTEXT (type)
2895               && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL
2896               && !processing_template_decl)
2897             VARRAY_PUSH_TREE (local_classes, type);
2898
2899           if (!uses_template_parms (type))
2900             {
2901               if (flag_new_abi)
2902                 DECL_ASSEMBLER_NAME (d) = mangle_type (type);
2903               else
2904                 DECL_ASSEMBLER_NAME (d)
2905                   = get_identifier (build_overload_name (type, 1, 1));
2906             }
2907         }
2908       if (b->parm_flag == 2)
2909         {
2910           if (!COMPLETE_TYPE_P (current_class_type))
2911             CLASSTYPE_TAGS (current_class_type) = b->tags;
2912         }
2913     }
2914
2915   if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2916     /* Use the canonical TYPE_DECL for this node.  */
2917     TYPE_STUB_DECL (type) = TYPE_NAME (type);
2918   else
2919     {
2920       /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2921          will be the tagged type we just added to the current
2922          binding level.  This fake NULL-named TYPE_DECL node helps
2923          dwarfout.c to know when it needs to output a
2924          representation of a tagged type, and it also gives us a
2925          convenient place to record the "scope start" address for
2926          the tagged type.  */
2927
2928       tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2929       TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2930     }
2931 }
2932
2933 /* Counter used to create anonymous type names.  */
2934
2935 static int anon_cnt = 0;
2936
2937 /* Return an IDENTIFIER which can be used as a name for
2938    anonymous structs and unions.  */
2939
2940 tree
2941 make_anon_name ()
2942 {
2943   char buf[32];
2944
2945   sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2946   return get_identifier (buf);
2947 }
2948
2949 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2950    This keeps dbxout from getting confused.  */
2951
2952 void
2953 clear_anon_tags ()
2954 {
2955   register struct binding_level *b;
2956   register tree tags;
2957   static int last_cnt = 0;
2958
2959   /* Fast out if no new anon names were declared.  */
2960   if (last_cnt == anon_cnt)
2961     return;
2962
2963   b = current_binding_level;
2964   while (b->tag_transparent)
2965     b = b->level_chain;
2966   tags = b->tags;
2967   while (tags)
2968     {
2969       /* A NULL purpose means we have already processed all tags
2970          from here to the end of the list.  */
2971       if (TREE_PURPOSE (tags) == NULL_TREE)
2972         break;
2973       if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2974         TREE_PURPOSE (tags) = NULL_TREE;
2975       tags = TREE_CHAIN (tags);
2976     }
2977   last_cnt = anon_cnt;
2978 }
2979 \f
2980 /* Subroutine of duplicate_decls: return truthvalue of whether
2981    or not types of these decls match.
2982
2983    For C++, we must compare the parameter list so that `int' can match
2984    `int&' in a parameter position, but `int&' is not confused with
2985    `const int&'.  */
2986
2987 int
2988 decls_match (newdecl, olddecl)
2989      tree newdecl, olddecl;
2990 {
2991   int types_match;
2992
2993   if (newdecl == olddecl)
2994     return 1;
2995
2996   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
2997     /* If the two DECLs are not even the same kind of thing, we're not
2998        interested in their types.  */
2999     return 0;
3000
3001   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3002     {
3003       tree f1 = TREE_TYPE (newdecl);
3004       tree f2 = TREE_TYPE (olddecl);
3005       tree p1 = TYPE_ARG_TYPES (f1);
3006       tree p2 = TYPE_ARG_TYPES (f2);
3007
3008       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
3009           && ! (DECL_EXTERN_C_P (newdecl)
3010                 && DECL_EXTERN_C_P (olddecl)))
3011         return 0;
3012
3013       if (TREE_CODE (f1) != TREE_CODE (f2))
3014         return 0;
3015
3016       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
3017         {
3018           if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
3019               && (DECL_BUILT_IN (olddecl)
3020 #ifndef NO_IMPLICIT_EXTERN_C
3021                   || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
3022                   || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
3023 #endif
3024               ))
3025             {
3026               types_match = self_promoting_args_p (p1);
3027               if (p1 == void_list_node)
3028                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
3029             }
3030 #ifndef NO_IMPLICIT_EXTERN_C
3031           else if (p1 == NULL_TREE
3032                    && (DECL_EXTERN_C_P (olddecl)
3033                        && DECL_IN_SYSTEM_HEADER (olddecl)
3034                        && !DECL_CLASS_SCOPE_P (olddecl))
3035                    && (DECL_EXTERN_C_P (newdecl)
3036                        && DECL_IN_SYSTEM_HEADER (newdecl)
3037                        && !DECL_CLASS_SCOPE_P (newdecl)))
3038             {
3039               types_match = self_promoting_args_p (p2);
3040               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
3041             }
3042 #endif
3043           else
3044             types_match = compparms (p1, p2);
3045         }
3046       else
3047         types_match = 0;
3048     }
3049   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3050     {
3051       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3052                                 DECL_TEMPLATE_PARMS (olddecl)))
3053         return 0;
3054
3055       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
3056           != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
3057         return 0;
3058
3059       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3060         types_match = 1;
3061       else
3062         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
3063                                    DECL_TEMPLATE_RESULT (newdecl));
3064     }
3065   else
3066     {
3067       if (TREE_TYPE (newdecl) == error_mark_node)
3068         types_match = TREE_TYPE (olddecl) == error_mark_node;
3069       else if (TREE_TYPE (olddecl) == NULL_TREE)
3070         types_match = TREE_TYPE (newdecl) == NULL_TREE;
3071       else if (TREE_TYPE (newdecl) == NULL_TREE)
3072         types_match = 0;
3073       else
3074         types_match = comptypes (TREE_TYPE (newdecl),
3075                                  TREE_TYPE (olddecl),
3076                                  COMPARE_REDECLARATION);
3077     }
3078
3079   return types_match;
3080 }
3081
3082 /* If NEWDECL is `static' and an `extern' was seen previously,
3083    warn about it.  OLDDECL is the previous declaration.
3084
3085    Note that this does not apply to the C++ case of declaring
3086    a variable `extern const' and then later `const'.
3087
3088    Don't complain about built-in functions, since they are beyond
3089    the user's control.  */
3090
3091 static void
3092 warn_extern_redeclared_static (newdecl, olddecl)
3093      tree newdecl, olddecl;
3094 {
3095   static const char *explicit_extern_static_warning
3096     = "`%D' was declared `extern' and later `static'";
3097   static const char *implicit_extern_static_warning
3098     = "`%D' was declared implicitly `extern' and later `static'";
3099
3100   tree name;
3101
3102   if (TREE_CODE (newdecl) == TYPE_DECL
3103       || TREE_CODE (newdecl) == TEMPLATE_DECL
3104       || TREE_CODE (newdecl) == CONST_DECL)
3105     return;
3106
3107   /* Don't get confused by static member functions; that's a different
3108      use of `static'.  */
3109   if (TREE_CODE (newdecl) == FUNCTION_DECL
3110       && DECL_STATIC_FUNCTION_P (newdecl))
3111     return;
3112
3113   /* If the old declaration was `static', or the new one isn't, then
3114      then everything is OK.  */
3115   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
3116     return;
3117
3118   /* It's OK to declare a builtin function as `static'.  */
3119   if (TREE_CODE (olddecl) == FUNCTION_DECL
3120       && DECL_ARTIFICIAL (olddecl))
3121     return;
3122
3123   name = DECL_ASSEMBLER_NAME (newdecl);
3124   cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
3125               ? implicit_extern_static_warning
3126               : explicit_extern_static_warning, newdecl);
3127   cp_pedwarn_at ("previous declaration of `%D'", olddecl);
3128 }
3129
3130 /* Handle when a new declaration NEWDECL has the same name as an old
3131    one OLDDECL in the same binding contour.  Prints an error message
3132    if appropriate.
3133
3134    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
3135    Otherwise, return 0.  */
3136
3137 int
3138 duplicate_decls (newdecl, olddecl)
3139      tree newdecl, olddecl;
3140 {
3141   unsigned olddecl_uid = DECL_UID (olddecl);
3142   int olddecl_friend = 0, types_match = 0;
3143   int new_defines_function = 0;
3144
3145   if (newdecl == olddecl)
3146     return 1;
3147
3148   types_match = decls_match (newdecl, olddecl);
3149
3150   /* If either the type of the new decl or the type of the old decl is an
3151      error_mark_node, then that implies that we have already issued an
3152      error (earlier) for some bogus type specification, and in that case,
3153      it is rather pointless to harass the user with yet more error message
3154      about the same declaration, so just pretend the types match here.  */
3155   if (TREE_TYPE (newdecl) == error_mark_node
3156       || TREE_TYPE (olddecl) == error_mark_node)
3157     types_match = 1;
3158
3159   /* Check for redeclaration and other discrepancies. */
3160   if (TREE_CODE (olddecl) == FUNCTION_DECL
3161       && DECL_ARTIFICIAL (olddecl))
3162     {
3163       if (TREE_CODE (newdecl) != FUNCTION_DECL)
3164         {
3165           /* If you declare a built-in or predefined function name as static,
3166              the old definition is overridden, but optionally warn this was a
3167              bad choice of name.  */
3168           if (! TREE_PUBLIC (newdecl))
3169             {
3170               if (warn_shadow)
3171                 cp_warning ("shadowing %s function `%#D'",
3172                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3173                             olddecl);
3174               /* Discard the old built-in function.  */
3175               return 0;
3176             }
3177           /* If the built-in is not ansi, then programs can override
3178              it even globally without an error.  */
3179           else if (! DECL_BUILT_IN (olddecl))
3180             cp_warning ("library function `%#D' redeclared as non-function `%#D'",
3181                         olddecl, newdecl);
3182           else
3183             {
3184               cp_error ("declaration of `%#D'", newdecl);
3185               cp_error ("conflicts with built-in declaration `%#D'",
3186                         olddecl);
3187             }
3188           return 0;
3189         }
3190       else if (!types_match)
3191         {
3192           if ((DECL_EXTERN_C_P (newdecl)
3193                && DECL_EXTERN_C_P (olddecl))
3194               || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3195                             TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3196             {
3197               /* A near match; override the builtin.  */
3198
3199               if (TREE_PUBLIC (newdecl))
3200                 {
3201                   cp_warning ("new declaration `%#D'", newdecl);
3202                   cp_warning ("ambiguates built-in declaration `%#D'",
3203                               olddecl);
3204                 }
3205               else if (warn_shadow)
3206                 cp_warning ("shadowing %s function `%#D'",
3207                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3208                             olddecl);
3209             }
3210           else
3211             /* Discard the old built-in function.  */
3212             return 0;
3213         }
3214
3215       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3216         {
3217           /* If a builtin function is redeclared as `static', merge
3218              the declarations, but make the original one static.  */
3219           DECL_THIS_STATIC (olddecl) = 1;
3220           TREE_PUBLIC (olddecl) = 0;
3221
3222           /* Make the old declaration consistent with the new one so
3223              that all remnants of the builtin-ness of this function
3224              will be banished.  */
3225           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3226           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3227           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3228           SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (newdecl),
3229                                        newdecl);
3230         }
3231     }
3232   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3233     {
3234       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3235            && TREE_CODE (newdecl) != TYPE_DECL
3236            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3237                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3238           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3239               && TREE_CODE (olddecl) != TYPE_DECL
3240               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3241                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3242                         == TYPE_DECL))))
3243         {
3244           /* We do nothing special here, because C++ does such nasty
3245              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
3246              get shadowed, and know that if we need to find a TYPE_DECL
3247              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3248              slot of the identifier.  */
3249           return 0;
3250         }
3251
3252       if ((TREE_CODE (newdecl) == FUNCTION_DECL
3253            && DECL_FUNCTION_TEMPLATE_P (olddecl))
3254           || (TREE_CODE (olddecl) == FUNCTION_DECL
3255               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3256         return 0;
3257
3258       cp_error ("`%#D' redeclared as different kind of symbol", newdecl);
3259       if (TREE_CODE (olddecl) == TREE_LIST)
3260         olddecl = TREE_VALUE (olddecl);
3261       cp_error_at ("previous declaration of `%#D'", olddecl);
3262
3263       /* New decl is completely inconsistent with the old one =>
3264          tell caller to replace the old one.  */
3265
3266       return 0;
3267     }
3268   else if (!types_match)
3269     {
3270       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
3271         /* These are certainly not duplicate declarations; they're
3272            from different scopes.  */
3273         return 0;
3274
3275       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3276         {
3277           /* The name of a class template may not be declared to refer to
3278              any other template, class, function, object, namespace, value,
3279              or type in the same scope.  */
3280           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3281               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3282             {
3283               cp_error ("declaration of template `%#D'", newdecl);
3284               cp_error_at ("conflicts with previous declaration `%#D'",
3285                            olddecl);
3286             }
3287           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3288                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3289                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3290                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3291                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3292                                            DECL_TEMPLATE_PARMS (olddecl)))
3293             {
3294               cp_error ("new declaration `%#D'", newdecl);
3295               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3296             }
3297           return 0;
3298         }
3299       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3300         {
3301           if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
3302             {
3303               cp_error ("declaration of C function `%#D' conflicts with",
3304                         newdecl);
3305               cp_error_at ("previous declaration `%#D' here", olddecl);
3306             }
3307           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3308                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3309             {
3310               cp_error ("new declaration `%#D'", newdecl);
3311               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3312             }
3313           else
3314             return 0;
3315         }
3316
3317       /* Already complained about this, so don't do so again.  */
3318       else if (current_class_type == NULL_TREE
3319           || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3320         {
3321           cp_error ("conflicting types for `%#D'", newdecl);
3322           cp_error_at ("previous declaration as `%#D'", olddecl);
3323         }
3324     }
3325   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3326             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3327                  && (!DECL_TEMPLATE_INFO (newdecl)
3328                      || (DECL_TI_TEMPLATE (newdecl)
3329                          != DECL_TI_TEMPLATE (olddecl))))
3330                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3331                     && (!DECL_TEMPLATE_INFO (olddecl)
3332                         || (DECL_TI_TEMPLATE (olddecl)
3333                             != DECL_TI_TEMPLATE (newdecl))))))
3334     /* It's OK to have a template specialization and a non-template
3335        with the same type, or to have specializations of two
3336        different templates with the same type.  Note that if one is a
3337        specialization, and the other is an instantiation of the same
3338        template, that we do not exit at this point.  That situation
3339        can occur if we instantiate a template class, and then
3340        specialize one of its methods.  This situation is legal, but
3341        the declarations must be merged in the usual way.  */
3342     return 0;
3343   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3344            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3345                 && !DECL_USE_TEMPLATE (newdecl))
3346                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3347                    && !DECL_USE_TEMPLATE (olddecl))))
3348     /* One of the declarations is a template instantiation, and the
3349        other is not a template at all.  That's OK.  */
3350     return 0;
3351   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3352            && DECL_NAMESPACE_ALIAS (newdecl)
3353            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3354     /* Redeclaration of namespace alias, ignore it. */
3355     return 1;
3356   else
3357     {
3358       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3359       if (errmsg)
3360         {
3361           cp_error (errmsg, newdecl);
3362           if (DECL_NAME (olddecl) != NULL_TREE)
3363             cp_error_at ((DECL_INITIAL (olddecl)
3364                           && namespace_bindings_p ())
3365                          ? "`%#D' previously defined here"
3366                          : "`%#D' previously declared here", olddecl);
3367         }
3368       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3369                && DECL_INITIAL (olddecl) != NULL_TREE
3370                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3371                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3372         {
3373           /* Prototype decl follows defn w/o prototype.  */
3374           cp_warning_at ("prototype for `%#D'", newdecl);
3375           cp_warning_at ("follows non-prototype definition here", olddecl);
3376         }
3377       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3378                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3379         {
3380           /* extern "C" int foo ();
3381              int foo () { bar (); }
3382              is OK.  */
3383           if (current_lang_stack
3384               == &VARRAY_TREE (current_lang_base, 0))
3385             DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3386           else
3387             {
3388               cp_error_at ("previous declaration of `%#D' with %L linkage",
3389                            olddecl, DECL_LANGUAGE (olddecl));
3390               cp_error ("conflicts with new declaration with %L linkage",
3391                         DECL_LANGUAGE (newdecl));
3392             }
3393         }
3394
3395       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3396         ;
3397       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3398         {
3399           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3400           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3401           int i = 1;
3402
3403           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3404             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3405
3406           for (; t1 && t1 != void_list_node;
3407                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3408             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3409               {
3410                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3411                                            TREE_PURPOSE (t2)))
3412                   {
3413                     if (pedantic)
3414                       {
3415                         cp_pedwarn ("default argument given for parameter %d of `%#D'",
3416                                     i, newdecl);
3417                         cp_pedwarn_at ("after previous specification in `%#D'",
3418                                        olddecl);
3419                       }
3420                   }
3421                 else
3422                   {
3423                     cp_error ("default argument given for parameter %d of `%#D'",
3424                               i, newdecl);
3425                     cp_error_at ("after previous specification in `%#D'",
3426                                  olddecl);
3427                   }
3428               }
3429
3430           if (DECL_THIS_INLINE (newdecl) && ! DECL_THIS_INLINE (olddecl)
3431               && TREE_ADDRESSABLE (olddecl) && warn_inline)
3432             {
3433               cp_warning ("`%#D' was used before it was declared inline",
3434                           newdecl);
3435               cp_warning_at ("previous non-inline declaration here",
3436                              olddecl);
3437             }
3438         }
3439     }
3440
3441   /* If new decl is `static' and an `extern' was seen previously,
3442      warn about it.  */
3443   warn_extern_redeclared_static (newdecl, olddecl);
3444
3445   /* We have committed to returning 1 at this point.  */
3446   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3447     {
3448       /* Now that functions must hold information normally held
3449          by field decls, there is extra work to do so that
3450          declaration information does not get destroyed during
3451          definition.  */
3452       if (DECL_VINDEX (olddecl))
3453         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3454       if (DECL_VIRTUAL_CONTEXT (olddecl))
3455         DECL_VIRTUAL_CONTEXT (newdecl) = DECL_VIRTUAL_CONTEXT (olddecl);
3456       if (DECL_CONTEXT (olddecl))
3457         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3458       if (DECL_PENDING_INLINE_INFO (newdecl) == (struct pending_inline *)0)
3459         DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3460       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3461       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3462       DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3463       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3464       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3465       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3466       DECL_LANG_SPECIFIC (newdecl)->u2 = DECL_LANG_SPECIFIC (olddecl)->u2;
3467       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3468
3469       /* Optionally warn about more than one declaration for the same
3470          name, but don't warn about a function declaration followed by a
3471          definition.  */
3472       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3473           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3474           /* Don't warn about extern decl followed by definition. */
3475           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3476           /* Don't warn about friends, let add_friend take care of it. */
3477           && ! DECL_FRIEND_P (newdecl))
3478         {
3479           cp_warning ("redundant redeclaration of `%D' in same scope", newdecl);
3480           cp_warning_at ("previous declaration of `%D'", olddecl);
3481         }
3482     }
3483
3484   /* Deal with C++: must preserve virtual function table size.  */
3485   if (TREE_CODE (olddecl) == TYPE_DECL)
3486     {
3487       register tree newtype = TREE_TYPE (newdecl);
3488       register tree oldtype = TREE_TYPE (olddecl);
3489
3490       if (newtype != error_mark_node && oldtype != error_mark_node
3491           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3492         {
3493           CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
3494           CLASSTYPE_FRIEND_CLASSES (newtype)
3495             = CLASSTYPE_FRIEND_CLASSES (oldtype);
3496         }
3497
3498       DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
3499     }
3500
3501   /* Copy all the DECL_... slots specified in the new decl
3502      except for any that we copy here from the old type.  */
3503   DECL_MACHINE_ATTRIBUTES (newdecl)
3504     = merge_machine_decl_attributes (olddecl, newdecl);
3505
3506   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3507     {
3508       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3509       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3510         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3511                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3512
3513       return 1;
3514     }
3515
3516   if (types_match)
3517     {
3518       /* Automatically handles default parameters.  */
3519       tree oldtype = TREE_TYPE (olddecl);
3520       tree newtype;
3521
3522       /* Merge the data types specified in the two decls.  */
3523       newtype = common_type (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3524
3525       if (TREE_CODE (newdecl) == VAR_DECL)
3526         DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3527       /* Do this after calling `common_type' so that default
3528          parameters don't confuse us.  */
3529       else if (TREE_CODE (newdecl) == FUNCTION_DECL
3530           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3531               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3532         {
3533           TREE_TYPE (newdecl) = build_exception_variant (newtype,
3534                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3535           TREE_TYPE (olddecl) = build_exception_variant (newtype,
3536                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
3537
3538           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3539               && DECL_SOURCE_LINE (olddecl) != 0
3540               && flag_exceptions
3541               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3542                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3543             {
3544               cp_error ("declaration of `%F' throws different exceptions",
3545                         newdecl);
3546               cp_error_at ("than previous declaration `%F'", olddecl);
3547             }
3548         }
3549       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3550
3551       /* Lay the type out, unless already done.  */
3552       if (! same_type_p (newtype, oldtype)
3553           && TREE_TYPE (newdecl) != error_mark_node
3554           && !(processing_template_decl && uses_template_parms (newdecl)))
3555         layout_type (TREE_TYPE (newdecl));
3556
3557       if ((TREE_CODE (newdecl) == VAR_DECL
3558            || TREE_CODE (newdecl) == PARM_DECL
3559            || TREE_CODE (newdecl) == RESULT_DECL
3560            || TREE_CODE (newdecl) == FIELD_DECL
3561            || TREE_CODE (newdecl) == TYPE_DECL)
3562           && !(processing_template_decl && uses_template_parms (newdecl)))
3563         layout_decl (newdecl, 0);
3564
3565       /* Merge the type qualifiers.  */
3566       if (TREE_READONLY (newdecl))
3567         TREE_READONLY (olddecl) = 1;
3568       if (TREE_THIS_VOLATILE (newdecl))
3569         TREE_THIS_VOLATILE (olddecl) = 1;
3570
3571       /* Merge the initialization information.  */
3572       if (DECL_INITIAL (newdecl) == NULL_TREE
3573           && DECL_INITIAL (olddecl) != NULL_TREE)
3574         {
3575           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3576           DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
3577           DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
3578           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3579               && DECL_LANG_SPECIFIC (newdecl)
3580               && DECL_LANG_SPECIFIC (olddecl))
3581             DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3582         }
3583
3584       /* Merge the section attribute.
3585          We want to issue an error if the sections conflict but that must be
3586          done later in decl_attributes since we are called before attributes
3587          are assigned.  */
3588       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3589         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3590
3591       /* Keep the old rtl since we can safely use it.  */
3592       DECL_RTL (newdecl) = DECL_RTL (olddecl);
3593
3594       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3595         {
3596           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3597             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3598           DECL_NO_CHECK_MEMORY_USAGE (newdecl)
3599             |= DECL_NO_CHECK_MEMORY_USAGE (olddecl);
3600           DECL_NO_LIMIT_STACK (newdecl)
3601             |= DECL_NO_LIMIT_STACK (olddecl);
3602         }
3603     }
3604   /* If cannot merge, then use the new type and qualifiers,
3605      and don't preserve the old rtl.  */
3606   else
3607     {
3608       /* Clean out any memory we had of the old declaration.  */
3609       tree oldstatic = value_member (olddecl, static_aggregates);
3610       if (oldstatic)
3611         TREE_VALUE (oldstatic) = error_mark_node;
3612
3613       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3614       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3615       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3616       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3617     }
3618
3619   /* Merge the storage class information.  */
3620   DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
3621   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3622   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3623   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3624   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3625   if (! DECL_EXTERNAL (olddecl))
3626     DECL_EXTERNAL (newdecl) = 0;
3627
3628   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3629     {
3630       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3631       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3632       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3633       DECL_TEMPLATE_INSTANTIATED (newdecl)
3634         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3635       /* Don't really know how much of the language-specific
3636          values we should copy from old to new.  */
3637       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3638       DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
3639       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3640       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3641       olddecl_friend = DECL_FRIEND_P (olddecl);
3642
3643       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
3644       if (TREE_CODE (newdecl) == FUNCTION_DECL
3645           || DECL_FUNCTION_TEMPLATE_P (newdecl))
3646         DECL_BEFRIENDING_CLASSES (newdecl)
3647           = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3648                      DECL_BEFRIENDING_CLASSES (olddecl));
3649     }
3650
3651   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3652     {
3653       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3654           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3655         {
3656           /* If newdecl is not a specialization, then it is not a
3657              template-related function at all.  And that means that we
3658              shoud have exited above, returning 0.  */
3659           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3660                               0);
3661
3662           if (TREE_USED (olddecl))
3663             /* From [temp.expl.spec]:
3664
3665                If a template, a member template or the member of a class
3666                template is explicitly specialized then that
3667                specialization shall be declared before the first use of
3668                that specialization that would cause an implicit
3669                instantiation to take place, in every translation unit in
3670                which such a use occurs.  */
3671             cp_error ("explicit specialization of %D after first use",
3672                       olddecl);
3673
3674           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3675         }
3676       DECL_THIS_INLINE (newdecl) |= DECL_THIS_INLINE (olddecl);
3677
3678       /* If either decl says `inline', this fn is inline, unless its
3679          definition was passed already.  */
3680       if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3681         DECL_INLINE (olddecl) = 1;
3682       DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3683
3684       if (! types_match)
3685         {
3686           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3687           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3688           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3689         }
3690       if (! types_match || new_defines_function)
3691         {
3692           /* These need to be copied so that the names are available.
3693              Note that if the types do match, we'll preserve inline
3694              info and other bits, but if not, we won't.  */
3695           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3696           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3697         }
3698       if (new_defines_function)
3699         /* If defining a function declared with other language
3700            linkage, use the previously declared language linkage.  */
3701         DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3702       else if (types_match)
3703         {
3704           /* If redeclaring a builtin function, and not a definition,
3705              it stays built in.  */
3706           if (DECL_BUILT_IN (olddecl))
3707             {
3708               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3709               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3710               /* If we're keeping the built-in definition, keep the rtl,
3711                  regardless of declaration matches.  */
3712               DECL_RTL (newdecl) = DECL_RTL (olddecl);
3713             }
3714           else
3715             DECL_FRAME_SIZE (newdecl) = DECL_FRAME_SIZE (olddecl);
3716
3717           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3718           if ((DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl)))
3719             /* Previously saved insns go together with
3720                the function's previous definition.  */
3721             DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3722           /* Don't clear out the arguments if we're redefining a function.  */
3723           if (DECL_ARGUMENTS (olddecl))
3724             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3725         }
3726     }
3727
3728   if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3729     {
3730       NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3731     }
3732
3733   /* Now preserve various other info from the definition.  */
3734   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3735   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3736   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3737   DECL_ASSEMBLER_NAME (newdecl) = DECL_ASSEMBLER_NAME (olddecl);
3738
3739   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3740     {
3741       int function_size;
3742
3743       function_size = sizeof (struct tree_decl);
3744
3745       bcopy ((char *) newdecl + sizeof (struct tree_common),
3746              (char *) olddecl + sizeof (struct tree_common),
3747              function_size - sizeof (struct tree_common));
3748
3749       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3750         {
3751           /* If newdecl is a template instantiation, it is possible that
3752              the following sequence of events has occurred:
3753
3754              o A friend function was declared in a class template.  The
3755              class template was instantiated.
3756
3757              o The instantiation of the friend declaration was
3758              recorded on the instantiation list, and is newdecl.
3759
3760              o Later, however, instantiate_class_template called pushdecl
3761              on the newdecl to perform name injection.  But, pushdecl in
3762              turn called duplicate_decls when it discovered that another
3763              declaration of a global function with the same name already
3764              existed.
3765
3766              o Here, in duplicate_decls, we decided to clobber newdecl.
3767
3768              If we're going to do that, we'd better make sure that
3769              olddecl, and not newdecl, is on the list of
3770              instantiations so that if we try to do the instantiation
3771              again we won't get the clobbered declaration.  */
3772
3773           tree tmpl = DECL_TI_TEMPLATE (newdecl);
3774           tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3775
3776           for (; decls; decls = TREE_CHAIN (decls))
3777             if (TREE_VALUE (decls) == newdecl)
3778               TREE_VALUE (decls) = olddecl;
3779         }
3780     }
3781   else
3782     {
3783       bcopy ((char *) newdecl + sizeof (struct tree_common),
3784              (char *) olddecl + sizeof (struct tree_common),
3785              sizeof (struct tree_decl) - sizeof (struct tree_common)
3786              + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
3787     }
3788
3789   DECL_UID (olddecl) = olddecl_uid;
3790   if (olddecl_friend)
3791     DECL_FRIEND_P (olddecl) = 1;
3792
3793   /* NEWDECL contains the merged attribute lists.
3794      Update OLDDECL to be the same.  */
3795   DECL_MACHINE_ATTRIBUTES (olddecl) = DECL_MACHINE_ATTRIBUTES (newdecl);
3796
3797   return 1;
3798 }
3799
3800 /* Record a decl-node X as belonging to the current lexical scope.
3801    Check for errors (such as an incompatible declaration for the same
3802    name already seen in the same scope).
3803
3804    Returns either X or an old decl for the same name.
3805    If an old decl is returned, it may have been smashed
3806    to agree with what X says.  */
3807
3808 tree
3809 pushdecl (x)
3810      tree x;
3811 {
3812   register tree t;
3813   register tree name;
3814   int need_new_binding;
3815
3816   /* We shouldn't be calling pushdecl when we're generating RTL for a
3817      function that we already did semantic analysis on previously.  */
3818   my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3819                       19990913);
3820
3821   need_new_binding = 1;
3822
3823   if (DECL_TEMPLATE_PARM_P (x))
3824     /* Template parameters have no context; they are not X::T even
3825        when declared within a class or namespace.  */
3826     ;
3827   else
3828     {
3829       if (current_function_decl && x != current_function_decl
3830           /* A local declaration for a function doesn't constitute
3831              nesting.  */
3832           && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3833           /* A local declaration for an `extern' variable is in the
3834              scoped of the current namespace, not the current
3835              function.  */
3836           && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3837           && !DECL_CONTEXT (x))
3838         DECL_CONTEXT (x) = current_function_decl;
3839
3840       /* If this is the declaration for a namespace-scope function,
3841          but the declaration itself is in a local scope, mark the
3842          declaration.  */
3843       if (TREE_CODE (x) == FUNCTION_DECL
3844           && DECL_NAMESPACE_SCOPE_P (x)
3845           && current_function_decl
3846           && x != current_function_decl)
3847         DECL_LOCAL_FUNCTION_P (x) = 1;
3848     }
3849
3850   name = DECL_NAME (x);
3851   if (name)
3852     {
3853 #if 0
3854       /* Not needed...see below.  */
3855       char *file;
3856       int line;
3857 #endif
3858       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3859         name = TREE_OPERAND (name, 0);
3860
3861       /* Namespace-scoped variables are not found in the current level. */
3862       if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x))
3863         t = namespace_binding (name, DECL_CONTEXT (x));
3864       else
3865         t = lookup_name_current_level (name);
3866
3867       /* If we are declaring a function, and the result of name-lookup
3868          was an OVERLOAD, look for an overloaded instance that is
3869          actually the same as the function we are declaring.  (If
3870          there is one, we have to merge our declaration with the
3871          previous declaration.)  */
3872       if (t && TREE_CODE (t) == OVERLOAD)
3873         {
3874           tree match;
3875
3876           if (TREE_CODE (x) == FUNCTION_DECL)
3877             for (match = t; match; match = OVL_NEXT (match))
3878               {
3879                 if (DECL_ASSEMBLER_NAME (OVL_CURRENT (t))
3880                     == DECL_ASSEMBLER_NAME (x))
3881                   break;
3882               }
3883           else
3884             /* Just choose one.  */
3885             match = t;
3886
3887           if (match)
3888             t = OVL_CURRENT (match);
3889           else
3890             t = NULL_TREE;
3891         }
3892
3893       if (t == error_mark_node)
3894         {
3895           /* error_mark_node is 0 for a while during initialization!  */
3896           t = NULL_TREE;
3897           cp_error_at ("`%#D' used prior to declaration", x);
3898         }
3899       else if (t != NULL_TREE)
3900         {
3901           if (TREE_CODE (t) == PARM_DECL)
3902             {
3903               if (DECL_CONTEXT (t) == NULL_TREE)
3904                 fatal ("parse errors have confused me too much");
3905
3906               /* Check for duplicate params.  */
3907               if (duplicate_decls (x, t))
3908                 return t;
3909             }
3910           else if ((DECL_EXTERN_C_FUNCTION_P (x)
3911                     || DECL_FUNCTION_TEMPLATE_P (x))
3912                    && is_overloaded_fn (t))
3913             /* Don't do anything just yet. */;
3914           else if (t == wchar_decl_node)
3915             {
3916               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3917                 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x));
3918
3919               /* Throw away the redeclaration.  */
3920               return t;
3921             }
3922           else if (TREE_CODE (t) != TREE_CODE (x))
3923             {
3924               if (duplicate_decls (x, t))
3925                 return t;
3926             }
3927           else if (duplicate_decls (x, t))
3928             {
3929               if (TREE_CODE (t) == TYPE_DECL)
3930                 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3931               else if (TREE_CODE (t) == FUNCTION_DECL)
3932                 check_default_args (t);
3933
3934               return t;
3935             }
3936           else if (DECL_MAIN_P (x))
3937             {
3938               /* A redeclaration of main, but not a duplicate of the
3939                  previous one.
3940
3941                  [basic.start.main]
3942
3943                  This function shall not be overloaded.  */
3944               cp_error_at ("invalid redeclaration of `%D'", t);
3945               cp_error ("as `%D'", x);
3946               /* We don't try to push this declaration since that
3947                  causes a crash.  */
3948               return x;
3949             }
3950         }
3951
3952       check_template_shadow (x);
3953
3954       /* If this is a function conjured up by the backend, massage it
3955          so it looks friendly.  */
3956       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
3957         {
3958           retrofit_lang_decl (x);
3959           DECL_LANGUAGE (x) = lang_c;
3960         }
3961
3962       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
3963         {
3964           t = push_overloaded_decl (x, PUSH_LOCAL);
3965           if (t != x)
3966             return t;
3967           if (!namespace_bindings_p ())
3968             /* We do not need to create a binding for this name;
3969                push_overloaded_decl will have already done so if
3970                necessary.  */
3971             need_new_binding = 0;
3972         }
3973       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
3974         {
3975           t = push_overloaded_decl (x, PUSH_GLOBAL);
3976           if (t == x)
3977             add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
3978           return t;
3979         }
3980
3981       /* If declaring a type as a typedef, copy the type (unless we're
3982          at line 0), and install this TYPE_DECL as the new type's typedef
3983          name.  See the extensive comment in ../c-decl.c (pushdecl). */
3984       if (TREE_CODE (x) == TYPE_DECL)
3985         {
3986           tree type = TREE_TYPE (x);
3987           if (DECL_SOURCE_LINE (x) == 0)
3988             {
3989               if (TYPE_NAME (type) == 0)
3990                 TYPE_NAME (type) = x;
3991             }
3992           else if (type != error_mark_node && TYPE_NAME (type) != x
3993                    /* We don't want to copy the type when all we're
3994                       doing is making a TYPE_DECL for the purposes of
3995                       inlining.  */
3996                    && (!TYPE_NAME (type)
3997                        || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
3998             {
3999               DECL_ORIGINAL_TYPE (x) = type;
4000               type = build_type_copy (type);
4001               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
4002               TYPE_NAME (type) = x;
4003               TREE_TYPE (x) = type;
4004             }
4005
4006           if (type != error_mark_node
4007               && TYPE_NAME (type)
4008               && TYPE_IDENTIFIER (type))
4009             set_identifier_type_value_with_scope (DECL_NAME (x), type,
4010                                                   current_binding_level);
4011
4012         }
4013
4014       /* Multiple external decls of the same identifier ought to match.
4015
4016          We get warnings about inline functions where they are defined.
4017          We get warnings about other functions from push_overloaded_decl.
4018
4019          Avoid duplicate warnings where they are used.  */
4020       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
4021         {
4022           tree decl;
4023
4024           decl = IDENTIFIER_NAMESPACE_VALUE (name);
4025           if (decl && TREE_CODE (decl) == OVERLOAD)
4026             decl = OVL_FUNCTION (decl);
4027
4028           if (decl && decl != error_mark_node
4029               && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
4030               /* If different sort of thing, we already gave an error.  */
4031               && TREE_CODE (decl) == TREE_CODE (x)
4032               && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
4033             {
4034               cp_pedwarn ("type mismatch with previous external decl", x);
4035               cp_pedwarn_at ("previous external decl of `%#D'", decl);
4036             }
4037         }
4038
4039       /* This name is new in its binding level.
4040          Install the new declaration and return it.  */
4041       if (namespace_bindings_p ())
4042         {
4043           /* Install a global value.  */
4044
4045           /* If the first global decl has external linkage,
4046              warn if we later see static one.  */
4047           if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
4048             TREE_PUBLIC (name) = 1;
4049
4050           /* Bind the mangled name for the entity.  In the future, we
4051              should not need to do this; mangled names are an
4052              implementation detail of which the front-end should not
4053              need to be aware.  */
4054           if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
4055                 && t != NULL_TREE)
4056               /* For an ordinary function, we create a binding from
4057                  the mangled name (i.e., NAME) to the DECL.  But, for
4058                  an `extern "C"' function, the mangled name and the
4059                  ordinary name are the same so we need not do this.  */
4060               && !DECL_EXTERN_C_FUNCTION_P (x))
4061             {
4062               tree mangled_name;
4063
4064               if (TREE_CODE (x) == TYPE_DECL || TREE_CODE (x) == VAR_DECL
4065                   || TREE_CODE (x) == NAMESPACE_DECL)
4066                 mangled_name = name;
4067               else
4068                 mangled_name = DECL_ASSEMBLER_NAME (x);
4069
4070               if (TREE_CODE (x) == FUNCTION_DECL)
4071                 my_friendly_assert
4072                   ((IDENTIFIER_GLOBAL_VALUE (mangled_name) == NULL_TREE)
4073                   || (IDENTIFIER_GLOBAL_VALUE (mangled_name) == x), 378);
4074               SET_IDENTIFIER_NAMESPACE_VALUE (mangled_name, x);
4075             }
4076
4077           /* Don't forget if the function was used via an implicit decl.  */
4078           if (IDENTIFIER_IMPLICIT_DECL (name)
4079               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
4080             TREE_USED (x) = 1;
4081
4082           /* Don't forget if its address was taken in that way.  */
4083           if (IDENTIFIER_IMPLICIT_DECL (name)
4084               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
4085             TREE_ADDRESSABLE (x) = 1;
4086
4087           /* Warn about mismatches against previous implicit decl.  */
4088           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
4089               /* If this real decl matches the implicit, don't complain.  */
4090               && ! (TREE_CODE (x) == FUNCTION_DECL
4091                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
4092             cp_warning
4093               ("`%D' was previously implicitly declared to return `int'", x);
4094
4095           /* If new decl is `static' and an `extern' was seen previously,
4096              warn about it.  */
4097           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
4098             warn_extern_redeclared_static (x, t);
4099         }
4100       else
4101         {
4102           /* Here to install a non-global value.  */
4103           tree oldlocal = IDENTIFIER_VALUE (name);
4104           tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
4105
4106           if (need_new_binding)
4107             {
4108               push_local_binding (name, x, 0);
4109               /* Because push_local_binding will hook X on to the
4110                  current_binding_level's name list, we don't want to
4111                  do that again below.  */
4112               need_new_binding = 0;
4113             }
4114
4115           /* If this is a TYPE_DECL, push it into the type value slot.  */
4116           if (TREE_CODE (x) == TYPE_DECL)
4117             set_identifier_type_value_with_scope (name, TREE_TYPE (x),
4118                                                   current_binding_level);
4119
4120           /* Clear out any TYPE_DECL shadowed by a namespace so that
4121              we won't think this is a type.  The C struct hack doesn't
4122              go through namespaces.  */
4123           if (TREE_CODE (x) == NAMESPACE_DECL)
4124             set_identifier_type_value_with_scope (name, NULL_TREE,
4125                                                   current_binding_level);
4126
4127           if (oldlocal)
4128             {
4129               tree d = oldlocal;
4130
4131               while (oldlocal
4132                      && TREE_CODE (oldlocal) == VAR_DECL
4133                      && DECL_DEAD_FOR_LOCAL (oldlocal))
4134                 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
4135
4136               if (oldlocal == NULL_TREE)
4137                 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
4138             }
4139
4140           /* If this is an extern function declaration, see if we
4141              have a global definition or declaration for the function.  */
4142           if (oldlocal == NULL_TREE
4143               && DECL_EXTERNAL (x)
4144               && oldglobal != NULL_TREE
4145               && TREE_CODE (x) == FUNCTION_DECL
4146               && TREE_CODE (oldglobal) == FUNCTION_DECL)
4147             {
4148               /* We have one.  Their types must agree.  */
4149               if (decls_match (x, oldglobal))
4150                 /* OK */;
4151               else
4152                 {
4153                   cp_warning ("extern declaration of `%#D' doesn't match", x);
4154                   cp_warning_at ("global declaration `%#D'", oldglobal);
4155                 }
4156             }
4157           /* If we have a local external declaration,
4158              and no file-scope declaration has yet been seen,
4159              then if we later have a file-scope decl it must not be static.  */
4160           if (oldlocal == NULL_TREE
4161               && oldglobal == NULL_TREE
4162               && DECL_EXTERNAL (x)
4163               && TREE_PUBLIC (x))
4164             TREE_PUBLIC (name) = 1;
4165
4166           /* Warn if shadowing an argument at the top level of the body.  */
4167           if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
4168               /* Inline decls shadow nothing.  */
4169               && !DECL_FROM_INLINE (x)
4170               && TREE_CODE (oldlocal) == PARM_DECL
4171               /* Don't complain if it's from an enclosing function.  */
4172               && DECL_CONTEXT (oldlocal) == current_function_decl
4173               && TREE_CODE (x) != PARM_DECL)
4174             {
4175               /* Go to where the parms should be and see if we
4176                  find them there.  */
4177               struct binding_level *b = current_binding_level->level_chain;
4178
4179               if (cleanup_label)
4180                 b = b->level_chain;
4181
4182               /* ARM $8.3 */
4183               if (b->parm_flag == 1)
4184                 cp_error ("declaration of `%#D' shadows a parameter", name);
4185             }
4186
4187           /* Maybe warn if shadowing something else.  */
4188           if (warn_shadow && !DECL_EXTERNAL (x)
4189               /* Inline decls shadow nothing.  */
4190               && !DECL_FROM_INLINE (x)
4191               /* No shadow warnings for internally generated vars.  */
4192               && ! DECL_ARTIFICIAL (x)
4193               /* No shadow warnings for vars made for inlining.  */
4194               && ! DECL_FROM_INLINE (x))
4195             {
4196               if (oldlocal != NULL_TREE && TREE_CODE (oldlocal) == PARM_DECL)
4197                 warning ("declaration of `%s' shadows a parameter",
4198                         IDENTIFIER_POINTER (name));
4199               else if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4200                        && current_class_ptr
4201                        && !TREE_STATIC (name))
4202                 warning ("declaration of `%s' shadows a member of `this'",
4203                         IDENTIFIER_POINTER (name));
4204               else if (oldlocal != NULL_TREE)
4205                 warning ("declaration of `%s' shadows previous local",
4206                         IDENTIFIER_POINTER (name));
4207               else if (oldglobal != NULL_TREE)
4208                 /* XXX shadow warnings in outer-more namespaces */
4209                 warning ("declaration of `%s' shadows global declaration",
4210                         IDENTIFIER_POINTER (name));
4211             }
4212         }
4213
4214       if (TREE_CODE (x) == FUNCTION_DECL)
4215         check_default_args (x);
4216
4217       /* Keep count of variables in this level with incomplete type.  */
4218       if (TREE_CODE (x) == VAR_DECL
4219           && TREE_TYPE (x) != error_mark_node
4220           && ((!COMPLETE_TYPE_P (TREE_TYPE (x))
4221                && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
4222               /* RTTI TD entries are created while defining the type_info.  */
4223               || (TYPE_LANG_SPECIFIC (TREE_TYPE (x))
4224                   && TYPE_BEING_DEFINED (TREE_TYPE (x)))))
4225         {
4226           if (namespace_bindings_p ())
4227             namespace_scope_incomplete
4228               = tree_cons (NULL_TREE, x, namespace_scope_incomplete);
4229           else
4230             current_binding_level->incomplete
4231               = tree_cons (NULL_TREE, x, current_binding_level->incomplete);
4232         }
4233     }
4234
4235   if (need_new_binding)
4236     add_decl_to_level (x,
4237                        DECL_NAMESPACE_SCOPE_P (x)
4238                        ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4239                        : current_binding_level);
4240
4241   return x;
4242 }
4243
4244 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
4245    caller to set DECL_CONTEXT properly.  */
4246
4247 static tree
4248 pushdecl_with_scope (x, level)
4249      tree x;
4250      struct binding_level *level;
4251 {
4252   register struct binding_level *b;
4253   tree function_decl = current_function_decl;
4254
4255   current_function_decl = NULL_TREE;
4256   if (level->parm_flag == 2)
4257     {
4258       b = class_binding_level;
4259       class_binding_level = level;
4260       pushdecl_class_level (x);
4261       class_binding_level = b;
4262     }
4263   else
4264     {
4265       b = current_binding_level;
4266       current_binding_level = level;
4267       x = pushdecl (x);
4268       current_binding_level = b;
4269     }
4270   current_function_decl = function_decl;
4271   return x;
4272 }
4273
4274 /* Like pushdecl, only it places X in the current namespace,
4275    if appropriate.  */
4276
4277 tree
4278 pushdecl_namespace_level (x)
4279      tree x;
4280 {
4281   register struct binding_level *b = current_binding_level;
4282   register tree t;
4283
4284   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4285
4286   /* Now, the type_shadowed stack may screw us.  Munge it so it does
4287      what we want.  */
4288   if (TREE_CODE (x) == TYPE_DECL)
4289     {
4290       tree name = DECL_NAME (x);
4291       tree newval;
4292       tree *ptr = (tree *)0;
4293       for (; b != global_binding_level; b = b->level_chain)
4294         {
4295           tree shadowed = b->type_shadowed;
4296           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4297             if (TREE_PURPOSE (shadowed) == name)
4298               {
4299                 ptr = &TREE_VALUE (shadowed);
4300                 /* Can't break out of the loop here because sometimes
4301                    a binding level will have duplicate bindings for
4302                    PT names.  It's gross, but I haven't time to fix it.  */
4303               }
4304         }
4305       newval = TREE_TYPE (x);
4306       if (ptr == (tree *)0)
4307         {
4308           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
4309              up here if this is changed to an assertion.  --KR  */
4310           SET_IDENTIFIER_TYPE_VALUE (name, newval);
4311         }
4312       else
4313         {
4314           *ptr = newval;
4315         }
4316     }
4317   return t;
4318 }
4319
4320 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4321    if appropriate.  */
4322
4323 tree
4324 pushdecl_top_level (x)
4325      tree x;
4326 {
4327   push_to_top_level ();
4328   x = pushdecl_namespace_level (x);
4329   pop_from_top_level ();
4330   return x;
4331 }
4332
4333 /* Make the declaration of X appear in CLASS scope.  */
4334
4335 void
4336 pushdecl_class_level (x)
4337      tree x;
4338 {
4339   /* Don't use DECL_ASSEMBLER_NAME here!  Everything that looks in class
4340      scope looks for the pre-mangled name.  */
4341   register tree name;
4342
4343   if (TREE_CODE (x) == OVERLOAD)
4344     x = OVL_CURRENT (x);
4345   name = DECL_NAME (x);
4346
4347   if (name)
4348     {
4349       push_class_level_binding (name, x);
4350       if (TREE_CODE (x) == TYPE_DECL)
4351         set_identifier_type_value (name, TREE_TYPE (x));
4352     }
4353   else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4354     {
4355       tree f;
4356
4357       for (f = TYPE_FIELDS (TREE_TYPE (x));
4358            f;
4359            f = TREE_CHAIN (f))
4360         pushdecl_class_level (f);
4361     }
4362 }
4363
4364 /* Enter DECL into the symbol table, if that's appropriate.  Returns
4365    DECL, or a modified version thereof.  */
4366
4367 tree
4368 maybe_push_decl (decl)
4369      tree decl;
4370 {
4371   tree type = TREE_TYPE (decl);
4372
4373   /* Add this decl to the current binding level, but not if it comes
4374      from another scope, e.g. a static member variable.  TEM may equal
4375      DECL or it may be a previous decl of the same name.  */
4376   if (decl == error_mark_node
4377       || (TREE_CODE (decl) != PARM_DECL
4378           && DECL_CONTEXT (decl) != NULL_TREE
4379           /* Definitions of namespace members outside their namespace are
4380              possible. */
4381           && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4382       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4383       || TREE_CODE (type) == UNKNOWN_TYPE
4384       /* The declaration of a template specialization does not affect
4385          the functions available for overload resolution, so we do not
4386          call pushdecl.  */
4387       || (TREE_CODE (decl) == FUNCTION_DECL
4388           && DECL_TEMPLATE_SPECIALIZATION (decl)))
4389     return decl;
4390   else
4391     return pushdecl (decl);
4392 }
4393
4394 /* Make the declaration(s) of X appear in CLASS scope
4395    under the name NAME.  */
4396
4397 void
4398 push_class_level_binding (name, x)
4399      tree name;
4400      tree x;
4401 {
4402   tree binding;
4403   /* The class_binding_level will be NULL if x is a template
4404      parameter name in a member template.  */
4405   if (!class_binding_level)
4406     return;
4407
4408   /* Make sure that this new member does not have the same name
4409      as a template parameter.  */
4410   if (TYPE_BEING_DEFINED (current_class_type))
4411     check_template_shadow (x);
4412
4413   /* If this declaration shadows a declaration from an enclosing
4414      class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4415      we leave this class.  Record the shadowed declaration here.  */
4416   binding = IDENTIFIER_BINDING (name);
4417   if (binding
4418       && ((TREE_CODE (x) == OVERLOAD
4419            && BINDING_VALUE (binding)
4420            && is_overloaded_fn (BINDING_VALUE (binding)))
4421           || INHERITED_VALUE_BINDING_P (binding)))
4422     {
4423       tree shadow;
4424       tree old_decl;
4425
4426       /* If the old binding was from a base class, and was for a tag
4427          name, slide it over to make room for the new binding.  The
4428          old binding is still visible if explicitly qualified with a
4429          class-key.  */
4430       if (INHERITED_VALUE_BINDING_P (binding)
4431           && BINDING_VALUE (binding)
4432           && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4433           && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4434           && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4435         {
4436           old_decl = BINDING_TYPE (binding);
4437           BINDING_TYPE (binding) = BINDING_VALUE (binding);
4438           BINDING_VALUE (binding) = NULL_TREE;
4439           INHERITED_VALUE_BINDING_P (binding) = 0;
4440         }
4441       else
4442         old_decl = BINDING_VALUE (binding);
4443
4444       /* There was already a binding for X containing fewer
4445          functions than are named in X.  Find the previous
4446          declaration of X on the class-shadowed list, and update it.  */
4447       for (shadow = class_binding_level->class_shadowed;
4448            shadow;
4449            shadow = TREE_CHAIN (shadow))
4450         if (TREE_PURPOSE (shadow) == name
4451             && TREE_TYPE (shadow) == old_decl)
4452           {
4453             BINDING_VALUE (binding) = x;
4454             INHERITED_VALUE_BINDING_P (binding) = 0;
4455             TREE_TYPE (shadow) = x;
4456             return;
4457           }
4458     }
4459
4460   /* If we didn't replace an existing binding, put the binding on the
4461      stack of bindings for the identifier, and update
4462      IDENTIFIER_CLASS_VALUE.  */
4463   if (push_class_binding (name, x))
4464     {
4465       class_binding_level->class_shadowed
4466         = tree_cons (name, IDENTIFIER_CLASS_VALUE (name),
4467                      class_binding_level->class_shadowed);
4468       /* Record the value we are binding NAME to so that we can know
4469          what to pop later.  */
4470       TREE_TYPE (class_binding_level->class_shadowed) = x;
4471     }
4472 }
4473
4474 /* Insert another USING_DECL into the current binding level, returning
4475    this declaration. If this is a redeclaration, do nothing, and
4476    return NULL_TREE if this not in namespace scope (in namespace
4477    scope, a using decl might extend any previous bindings).  */
4478
4479 tree
4480 push_using_decl (scope, name)
4481      tree scope;
4482      tree name;
4483 {
4484   tree decl;
4485
4486   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4487   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4488   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4489     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4490       break;
4491   if (decl)
4492     return namespace_bindings_p () ? decl : NULL_TREE;
4493   decl = build_lang_decl (USING_DECL, name, void_type_node);
4494   DECL_INITIAL (decl) = scope;
4495   TREE_CHAIN (decl) = current_binding_level->usings;
4496   current_binding_level->usings = decl;
4497   return decl;
4498 }
4499
4500 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4501    changed (i.e. there was already a directive), or the fresh
4502    TREE_LIST otherwise.  */
4503
4504 tree
4505 push_using_directive (used)
4506      tree used;
4507 {
4508   tree ud = current_binding_level->using_directives;
4509   tree iter, ancestor;
4510
4511   /* Check if we already have this. */
4512   if (purpose_member (used, ud) != NULL_TREE)
4513     return NULL_TREE;
4514
4515   /* Recursively add all namespaces used. */
4516   for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4517     push_using_directive (TREE_PURPOSE (iter));
4518
4519   ancestor = namespace_ancestor (current_decl_namespace (), used);
4520   ud = current_binding_level->using_directives;
4521   ud = tree_cons (used, ancestor, ud);
4522   current_binding_level->using_directives = ud;
4523   return ud;
4524 }
4525
4526 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4527    other definitions already in place.  We get around this by making
4528    the value of the identifier point to a list of all the things that
4529    want to be referenced by that name.  It is then up to the users of
4530    that name to decide what to do with that list.
4531
4532    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
4533    DECL_TEMPLATE_RESULT.  It is dealt with the same way.
4534
4535    FLAGS is a bitwise-or of the following values:
4536      PUSH_LOCAL: Bind DECL in the current scope, rather than at
4537                  namespace scope.
4538      PUSH_USING: DECL is being pushed as the result of a using
4539                  declaration.
4540
4541    The value returned may be a previous declaration if we guessed wrong
4542    about what language DECL should belong to (C or C++).  Otherwise,
4543    it's always DECL (and never something that's not a _DECL).  */
4544
4545 tree
4546 push_overloaded_decl (decl, flags)
4547      tree decl;
4548      int flags;
4549 {
4550   tree name = DECL_NAME (decl);
4551   tree old;
4552   tree new_binding;
4553   int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4554
4555   if (doing_global)
4556     old = namespace_binding (name, DECL_CONTEXT (decl));
4557   else
4558     old = lookup_name_current_level (name);
4559
4560   if (old)
4561     {
4562       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4563         {
4564           tree t = TREE_TYPE (old);
4565           if (IS_AGGR_TYPE (t) && warn_shadow
4566               && (! DECL_IN_SYSTEM_HEADER (decl)
4567                   || ! DECL_IN_SYSTEM_HEADER (old)))
4568             cp_warning ("`%#D' hides constructor for `%#T'", decl, t);
4569           old = NULL_TREE;
4570         }
4571       else if (is_overloaded_fn (old))
4572         {
4573           tree tmp;
4574
4575           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4576             {
4577               tree fn = OVL_CURRENT (tmp);
4578
4579               if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4580                   && !(flags & PUSH_USING)
4581                   && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4582                                 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4583                 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4584                           decl, fn);
4585
4586               if (duplicate_decls (decl, fn))
4587                 return fn;
4588             }
4589         }
4590       else if (old == error_mark_node)
4591         /* Ignore the undefined symbol marker.  */
4592         old = NULL_TREE;
4593       else
4594         {
4595           cp_error_at ("previous non-function declaration `%#D'", old);
4596           cp_error ("conflicts with function declaration `%#D'", decl);
4597           return decl;
4598         }
4599     }
4600
4601   if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4602     {
4603       if (old && TREE_CODE (old) != OVERLOAD)
4604         new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4605       else
4606         new_binding = ovl_cons (decl, old);
4607       if (flags & PUSH_USING)
4608         OVL_USED (new_binding) = 1;
4609     }
4610   else
4611     /* NAME is not ambiguous.  */
4612     new_binding = decl;
4613
4614   if (doing_global)
4615     set_namespace_binding (name, current_namespace, new_binding);
4616   else
4617     {
4618       /* We only create an OVERLOAD if there was a previous binding at
4619          this level, or if decl is a template. In the former case, we
4620          need to remove the old binding and replace it with the new
4621          binding.  We must also run through the NAMES on the binding
4622          level where the name was bound to update the chain.  */
4623
4624       if (TREE_CODE (new_binding) == OVERLOAD && old)
4625         {
4626           tree *d;
4627
4628           for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4629                *d;
4630                d = &TREE_CHAIN (*d))
4631             if (*d == old
4632                 || (TREE_CODE (*d) == TREE_LIST
4633                     && TREE_VALUE (*d) == old))
4634               {
4635                 if (TREE_CODE (*d) == TREE_LIST)
4636                   /* Just replace the old binding with the new.  */
4637                   TREE_VALUE (*d) = new_binding;
4638                 else
4639                   /* Build a TREE_LIST to wrap the OVERLOAD.  */
4640                   *d = tree_cons (NULL_TREE, new_binding,
4641                                   TREE_CHAIN (*d));
4642
4643                 /* And update the CPLUS_BINDING node.  */
4644                 BINDING_VALUE (IDENTIFIER_BINDING (name))
4645                   = new_binding;
4646                 return decl;
4647               }
4648
4649           /* We should always find a previous binding in this case.  */
4650           my_friendly_abort (0);
4651         }
4652
4653       /* Install the new binding.  */
4654       push_local_binding (name, new_binding, flags);
4655     }
4656
4657   return decl;
4658 }
4659 \f
4660 /* Generate an implicit declaration for identifier FUNCTIONID
4661    as a function of type int ().  Print a warning if appropriate.  */
4662
4663 tree
4664 implicitly_declare (functionid)
4665      tree functionid;
4666 {
4667   register tree decl;
4668
4669   /* We used to reuse an old implicit decl here,
4670      but this loses with inline functions because it can clobber
4671      the saved decl chains.  */
4672   decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4673
4674   DECL_EXTERNAL (decl) = 1;
4675   TREE_PUBLIC (decl) = 1;
4676
4677   /* ISO standard says implicit declarations are in the innermost block.
4678      So we record the decl in the standard fashion.  */
4679   pushdecl (decl);
4680   rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
4681
4682   if (warn_implicit
4683       /* Only one warning per identifier.  */
4684       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4685     {
4686       cp_pedwarn ("implicit declaration of function `%#D'", decl);
4687     }
4688
4689   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4690
4691   return decl;
4692 }
4693
4694 /* Return zero if the declaration NEWDECL is valid
4695    when the declaration OLDDECL (assumed to be for the same name)
4696    has already been seen.
4697    Otherwise return an error message format string with a %s
4698    where the identifier should go.  */
4699
4700 static const char *
4701 redeclaration_error_message (newdecl, olddecl)
4702      tree newdecl, olddecl;
4703 {
4704   if (TREE_CODE (newdecl) == TYPE_DECL)
4705     {
4706       /* Because C++ can put things into name space for free,
4707          constructs like "typedef struct foo { ... } foo"
4708          would look like an erroneous redeclaration.  */
4709       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4710         return 0;
4711       else
4712         return "redefinition of `%#D'";
4713     }
4714   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4715     {
4716       /* If this is a pure function, its olddecl will actually be
4717          the original initialization to `0' (which we force to call
4718          abort()).  Don't complain about redefinition in this case.  */
4719       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4720         return 0;
4721
4722       /* If both functions come from different namespaces, this is not
4723          a redeclaration - this is a conflict with a used function. */
4724       if (DECL_NAMESPACE_SCOPE_P (olddecl)
4725           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4726         return "`%D' conflicts with used function";
4727
4728       /* We'll complain about linkage mismatches in
4729          warn_extern_redeclared_static.  */
4730
4731       /* Defining the same name twice is no good.  */
4732       if (DECL_INITIAL (olddecl) != NULL_TREE
4733           && DECL_INITIAL (newdecl) != NULL_TREE)
4734         {
4735           if (DECL_NAME (olddecl) == NULL_TREE)
4736             return "`%#D' not declared in class";
4737           else
4738             return "redefinition of `%#D'";
4739         }
4740       return 0;
4741     }
4742   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4743     {
4744       if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4745            && (DECL_TEMPLATE_RESULT (newdecl)
4746                != DECL_TEMPLATE_RESULT (olddecl))
4747            && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4748            && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4749           || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4750               && COMPLETE_TYPE_P (TREE_TYPE (newdecl))
4751               && COMPLETE_TYPE_P (TREE_TYPE (olddecl))))
4752         return "redefinition of `%#D'";
4753       return 0;
4754     }
4755   else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
4756     {
4757       /* Objects declared at top level:  */
4758       /* If at least one is a reference, it's ok.  */
4759       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4760         return 0;
4761       /* Reject two definitions.  */
4762       return "redefinition of `%#D'";
4763     }
4764   else
4765     {
4766       /* Objects declared with block scope:  */
4767       /* Reject two definitions, and reject a definition
4768          together with an external reference.  */
4769       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4770         return "redeclaration of `%#D'";
4771       return 0;
4772     }
4773 }
4774 \f
4775 /* Create a new label, named ID.  */
4776
4777 static tree
4778 make_label_decl (id, local_p)
4779      tree id;
4780      int local_p;
4781 {
4782   tree decl;
4783
4784   decl = build_decl (LABEL_DECL, id, void_type_node);
4785   if (expanding_p)
4786     /* Make sure every label has an rtx.  */
4787     label_rtx (decl);
4788
4789   DECL_CONTEXT (decl) = current_function_decl;
4790   DECL_MODE (decl) = VOIDmode;
4791   C_DECLARED_LABEL_FLAG (decl) = local_p;
4792
4793   /* Say where one reference is to the label, for the sake of the
4794      error if it is not defined.  */
4795   DECL_SOURCE_LINE (decl) = lineno;
4796   DECL_SOURCE_FILE (decl) = input_filename;
4797
4798   /* Record the fact that this identifier is bound to this label.  */
4799   SET_IDENTIFIER_LABEL_VALUE (id, decl);
4800
4801   return decl;
4802 }
4803
4804 /* Record this label on the list of used labels so that we can check
4805    at the end of the function to see whether or not the label was
4806    actually defined, and so we can check when the label is defined whether
4807    this use is valid.  */
4808
4809 static void
4810 use_label (decl)
4811      tree decl;
4812 {
4813   if (named_label_uses == NULL
4814       || named_label_uses->names_in_scope != current_binding_level->names
4815       || named_label_uses->label_decl != decl)
4816     {
4817       struct named_label_use_list *new_ent;
4818       new_ent = ((struct named_label_use_list *)
4819                  ggc_alloc (sizeof (struct named_label_use_list)));
4820       new_ent->label_decl = decl;
4821       new_ent->names_in_scope = current_binding_level->names;
4822       new_ent->binding_level = current_binding_level;
4823       new_ent->lineno_o_goto = lineno;
4824       new_ent->filename_o_goto = input_filename;
4825       new_ent->next = named_label_uses;
4826       named_label_uses = new_ent;
4827     }
4828 }
4829
4830 /* Look for a label named ID in the current function.  If one cannot
4831    be found, create one.  (We keep track of used, but undefined,
4832    labels, and complain about them at the end of a function.)  */
4833
4834 tree
4835 lookup_label (id)
4836      tree id;
4837 {
4838   tree decl;
4839   struct named_label_list *ent;
4840
4841   /* You can't use labels at global scope.  */
4842   if (current_function_decl == NULL_TREE)
4843     {
4844       error ("label `%s' referenced outside of any function",
4845              IDENTIFIER_POINTER (id));
4846       return NULL_TREE;
4847     }
4848
4849   /* See if we've already got this label.  */
4850   decl = IDENTIFIER_LABEL_VALUE (id);
4851   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4852     return decl;
4853
4854   /* Record this label on the list of labels used in this function.
4855      We do this before calling make_label_decl so that we get the
4856      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
4857   ent = ((struct named_label_list *)
4858          ggc_alloc_cleared (sizeof (struct named_label_list)));
4859   ent->old_value = IDENTIFIER_LABEL_VALUE (id);
4860   ent->next = named_labels;
4861   named_labels = ent;
4862
4863   /* We need a new label.  */
4864   decl = make_label_decl (id, /*local_p=*/0);
4865
4866   /* Now fill in the information we didn't have before.  */
4867   ent->label_decl = decl;
4868
4869   return decl;
4870 }
4871
4872 /* Declare a local label named ID.  */
4873
4874 tree
4875 declare_local_label (id)
4876      tree id;
4877 {
4878   tree decl;
4879
4880   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4881      this scope we can restore the old value of
4882      IDENTIFIER_TYPE_VALUE.  */
4883   current_binding_level->shadowed_labels
4884     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4885                  current_binding_level->shadowed_labels);
4886   /* Look for the label.  */
4887   decl = make_label_decl (id, /*local_p=*/1);
4888   /* Now fill in the information we didn't have before.  */
4889   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4890
4891   return decl;
4892 }
4893
4894 /* Returns nonzero if it is ill-formed to jump past the declaration of
4895    DECL.  Returns 2 if it's also a real problem.  */
4896
4897 static int
4898 decl_jump_unsafe (decl)
4899      tree decl;
4900 {
4901   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
4902     return 0;
4903
4904   if (DECL_INITIAL (decl) == NULL_TREE
4905       && pod_type_p (TREE_TYPE (decl)))
4906     return 0;
4907
4908   /* This is really only important if we're crossing an initialization.
4909      The POD stuff is just pedantry; why should it matter if the class
4910      contains a field of pointer to member type?  */
4911   if (DECL_INITIAL (decl)
4912       || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
4913     return 2;
4914   return 1;
4915 }
4916
4917 /* Check that a single previously seen jump to a newly defined label
4918    is OK.  DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
4919    the jump context; NAMES are the names in scope in LEVEL at the jump
4920    context; FILE and LINE are the source position of the jump or 0.  */
4921
4922 static void
4923 check_previous_goto_1 (decl, level, names, file, line)
4924      tree decl;
4925      struct binding_level *level;
4926      tree names;
4927      const char *file;
4928      int line;
4929 {
4930   int identified = 0;
4931   int saw_eh = 0;
4932   struct binding_level *b = current_binding_level;
4933   for (; b; b = b->level_chain)
4934     {
4935       tree new_decls = b->names;
4936       tree old_decls = (b == level ? names : NULL_TREE);
4937       for (; new_decls != old_decls;
4938            new_decls = TREE_CHAIN (new_decls))
4939         {
4940           int problem = decl_jump_unsafe (new_decls);
4941           if (! problem)
4942             continue;
4943
4944           if (! identified)
4945             {
4946               if (decl)
4947                 cp_pedwarn ("jump to label `%D'", decl);
4948               else
4949                 pedwarn ("jump to case label");
4950
4951               if (file)
4952                 pedwarn_with_file_and_line (file, line, "  from here");
4953               identified = 1;
4954             }
4955
4956           if (problem > 1 && DECL_ARTIFICIAL (new_decls))
4957             /* Can't skip init of __exception_info.  */
4958             cp_error_at ("  enters catch block", new_decls);
4959           else if (problem > 1)
4960             cp_error_at ("  crosses initialization of `%#D'",
4961                          new_decls);
4962           else
4963             cp_pedwarn_at ("  enters scope of non-POD `%#D'",
4964                            new_decls);
4965         }
4966
4967       if (b == level)
4968         break;
4969       if (b->eh_region && ! saw_eh)
4970         {
4971           if (! identified)
4972             {
4973               if (decl)
4974                 cp_pedwarn ("jump to label `%D'", decl);
4975               else
4976                 pedwarn ("jump to case label");
4977
4978               if (file)
4979                 pedwarn_with_file_and_line (file, line, "  from here");
4980               identified = 1;
4981             }
4982           error ("  enters try block");
4983           saw_eh = 1;
4984         }
4985     }
4986 }
4987
4988 static void
4989 check_previous_goto (use)
4990      struct named_label_use_list *use;
4991 {
4992   check_previous_goto_1 (use->label_decl, use->binding_level,
4993                          use->names_in_scope, use->filename_o_goto,
4994                          use->lineno_o_goto);
4995 }
4996
4997 static void
4998 check_switch_goto (level)
4999      struct binding_level *level;
5000 {
5001   check_previous_goto_1 (NULL_TREE, level, level->names, NULL, 0);
5002 }
5003
5004 /* Check that any previously seen jumps to a newly defined label DECL
5005    are OK.  Called by define_label.  */
5006
5007 static void
5008 check_previous_gotos (decl)
5009      tree decl;
5010 {
5011   struct named_label_use_list **usep;
5012
5013   if (! TREE_USED (decl))
5014     return;
5015
5016   for (usep = &named_label_uses; *usep; )
5017     {
5018       struct named_label_use_list *use = *usep;
5019       if (use->label_decl == decl)
5020         {
5021           check_previous_goto (use);
5022           *usep = use->next;
5023         }
5024       else
5025         usep = &(use->next);
5026     }
5027 }
5028
5029 /* Check that a new jump to a label DECL is OK.  Called by
5030    finish_goto_stmt.  */
5031
5032 void
5033 check_goto (decl)
5034      tree decl;
5035 {
5036   int identified = 0;
5037   tree bad;
5038   struct named_label_list *lab;
5039
5040   /* We can't know where a computed goto is jumping.  So we assume
5041      that it's OK.  */
5042   if (! DECL_P (decl))
5043     return;
5044
5045   /* If the label hasn't been defined yet, defer checking.  */
5046   if (! DECL_INITIAL (decl))
5047     {
5048       use_label (decl);
5049       return;
5050     }
5051
5052   for (lab = named_labels; lab; lab = lab->next)
5053     if (decl == lab->label_decl)
5054       break;
5055
5056   /* If the label is not on named_labels it's a gcc local label, so
5057      it must be in an outer scope, so jumping to it is always OK.  */
5058   if (lab == 0)
5059     return;
5060
5061   if ((lab->eh_region || lab->bad_decls) && !identified)
5062     {
5063       cp_pedwarn_at ("jump to label `%D'", decl);
5064       pedwarn ("  from here");
5065       identified = 1;
5066     }
5067
5068   for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad))
5069     {
5070       tree b = TREE_VALUE (bad);
5071       int u = decl_jump_unsafe (b);
5072
5073       if (u > 1 && DECL_ARTIFICIAL (b))
5074         /* Can't skip init of __exception_info.  */
5075         cp_error_at ("  enters catch block", b);
5076       else if (u > 1)
5077         cp_error_at ("  skips initialization of `%#D'", b);
5078       else
5079         cp_pedwarn_at ("  enters scope of non-POD `%#D'", b);
5080     }
5081
5082   if (lab->eh_region)
5083     error ("  enters try block");
5084 }
5085
5086 /* Define a label, specifying the location in the source file.
5087    Return the LABEL_DECL node for the label, if the definition is valid.
5088    Otherwise return 0.  */
5089
5090 tree
5091 define_label (filename, line, name)
5092      const char *filename;
5093      int line;
5094      tree name;
5095 {
5096   tree decl = lookup_label (name);
5097   struct named_label_list *ent;
5098
5099   for (ent = named_labels; ent; ent = ent->next)
5100     if (ent->label_decl == decl)
5101       break;
5102
5103   /* After labels, make any new cleanups go into their
5104      own new (temporary) binding contour.  */
5105   current_binding_level->more_cleanups_ok = 0;
5106
5107   if (name == get_identifier ("wchar_t"))
5108     cp_pedwarn ("label named wchar_t");
5109
5110   if (DECL_INITIAL (decl) != NULL_TREE)
5111     {
5112       cp_error ("duplicate label `%D'", decl);
5113       return 0;
5114     }
5115   else
5116     {
5117       /* Mark label as having been defined.  */
5118       DECL_INITIAL (decl) = error_mark_node;
5119       /* Say where in the source.  */
5120       DECL_SOURCE_FILE (decl) = filename;
5121       DECL_SOURCE_LINE (decl) = line;
5122       if (ent)
5123         {
5124           ent->names_in_scope = current_binding_level->names;
5125           ent->binding_level = current_binding_level;
5126         }
5127       check_previous_gotos (decl);
5128       current_function_return_value = NULL_TREE;
5129       return decl;
5130     }
5131 }
5132
5133 struct cp_switch
5134 {
5135   struct binding_level *level;
5136   struct cp_switch *next;
5137 };
5138
5139 static struct cp_switch *switch_stack;
5140
5141 void
5142 push_switch ()
5143 {
5144   struct cp_switch *p
5145     = (struct cp_switch *) xmalloc (sizeof (struct cp_switch));
5146   p->level = current_binding_level;
5147   p->next = switch_stack;
5148   switch_stack = p;
5149 }
5150
5151 void
5152 pop_switch ()
5153 {
5154   struct cp_switch *cs;
5155
5156   cs = switch_stack;
5157   switch_stack = switch_stack->next;
5158   free (cs);
5159 }
5160
5161 /* Note that we've seen a definition of a case label, and complain if this
5162    is a bad place for one.  */
5163
5164 void
5165 define_case_label ()
5166 {
5167   tree cleanup = last_cleanup_this_contour ();
5168
5169   if (! switch_stack)
5170     /* Don't crash; we'll complain in do_case.  */
5171     return;
5172
5173   if (cleanup)
5174     {
5175       static int explained = 0;
5176       cp_warning_at ("destructor needed for `%#D'", TREE_PURPOSE (cleanup));
5177       warning ("where case label appears here");
5178       if (!explained)
5179         {
5180           warning ("(enclose actions of previous case statements requiring");
5181           warning ("destructors in their own binding contours.)");
5182           explained = 1;
5183         }
5184     }
5185
5186   check_switch_goto (switch_stack->level);
5187
5188   /* After labels, make any new cleanups go into their
5189      own new (temporary) binding contour.  */
5190
5191   current_binding_level->more_cleanups_ok = 0;
5192   current_function_return_value = NULL_TREE;
5193 }
5194 \f
5195 /* Return the list of declarations of the current level.
5196    Note that this list is in reverse order unless/until
5197    you nreverse it; and when you do nreverse it, you must
5198    store the result back using `storedecls' or you will lose.  */
5199
5200 tree
5201 getdecls ()
5202 {
5203   return current_binding_level->names;
5204 }
5205
5206 /* Return the list of type-tags (for structs, etc) of the current level.  */
5207
5208 tree
5209 gettags ()
5210 {
5211   return current_binding_level->tags;
5212 }
5213
5214 /* Store the list of declarations of the current level.
5215    This is done for the parameter declarations of a function being defined,
5216    after they are modified in the light of any missing parameters.  */
5217
5218 static void
5219 storedecls (decls)
5220      tree decls;
5221 {
5222   current_binding_level->names = decls;
5223 }
5224
5225 /* Similarly, store the list of tags of the current level.  */
5226
5227 void
5228 storetags (tags)
5229      tree tags;
5230 {
5231   current_binding_level->tags = tags;
5232 }
5233 \f
5234 /* Given NAME, an IDENTIFIER_NODE,
5235    return the structure (or union or enum) definition for that name.
5236    Searches binding levels from BINDING_LEVEL up to the global level.
5237    If THISLEVEL_ONLY is nonzero, searches only the specified context
5238    (but skips any tag-transparent contexts to find one that is
5239    meaningful for tags).
5240    FORM says which kind of type the caller wants;
5241    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5242    If the wrong kind of type is found, and it's not a template, an error is
5243    reported.  */
5244
5245 static tree
5246 lookup_tag (form, name, binding_level, thislevel_only)
5247      enum tree_code form;
5248      tree name;
5249      struct binding_level *binding_level;
5250      int thislevel_only;
5251 {
5252   register struct binding_level *level;
5253   /* Non-zero if, we should look past a template parameter level, even
5254      if THISLEVEL_ONLY.  */
5255   int allow_template_parms_p = 1;
5256
5257   for (level = binding_level; level; level = level->level_chain)
5258     {
5259       register tree tail;
5260       if (ANON_AGGRNAME_P (name))
5261         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5262           {
5263             /* There's no need for error checking here, because
5264                anon names are unique throughout the compilation.  */
5265             if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
5266               return TREE_VALUE (tail);
5267           }
5268       else if (level->namespace_p)
5269         /* Do namespace lookup. */
5270         for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
5271           {
5272             tree old = binding_for_name (name, tail);
5273
5274             /* If we just skipped past a template parameter level,
5275                even though THISLEVEL_ONLY, and we find a template
5276                class declaration, then we use the _TYPE node for the
5277                template.  See the example below.  */
5278             if (thislevel_only && !allow_template_parms_p
5279                 && old && BINDING_VALUE (old)
5280                 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
5281               old = TREE_TYPE (BINDING_VALUE (old));
5282             else
5283               old = BINDING_TYPE (old);
5284
5285             /* If it has an original type, it is a typedef, and we
5286                should not return it.  */
5287             if (old && DECL_ORIGINAL_TYPE (TYPE_NAME (old)))
5288               old = NULL_TREE;
5289             if (old && TREE_CODE (old) != form
5290                 && !(form != ENUMERAL_TYPE && TREE_CODE (old) == TEMPLATE_DECL))
5291               {
5292                 cp_error ("`%#D' redeclared as %C", old, form);
5293                 return NULL_TREE;
5294               }
5295             if (old)
5296               return old;
5297             if (thislevel_only || tail == global_namespace)
5298               return NULL_TREE;
5299           }
5300       else
5301         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5302           {
5303             if (TREE_PURPOSE (tail) == name)
5304               {
5305                 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5306                 /* Should tighten this up; it'll probably permit
5307                    UNION_TYPE and a struct template, for example.  */
5308                 if (code != form
5309                     && !(form != ENUMERAL_TYPE && code == TEMPLATE_DECL))
5310                   {
5311                     /* Definition isn't the kind we were looking for.  */
5312                     cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
5313                               form);
5314                     return NULL_TREE;
5315                   }
5316                 return TREE_VALUE (tail);
5317               }
5318           }
5319       if (thislevel_only && ! level->tag_transparent)
5320         {
5321           if (level->template_parms_p && allow_template_parms_p)
5322             {
5323               /* We must deal with cases like this:
5324
5325                    template <class T> struct S;
5326                    template <class T> struct S {};
5327
5328                  When looking up `S', for the second declaration, we
5329                  would like to find the first declaration.  But, we
5330                  are in the pseudo-global level created for the
5331                  template parameters, rather than the (surrounding)
5332                  namespace level.  Thus, we keep going one more level,
5333                  even though THISLEVEL_ONLY is non-zero.  */
5334               allow_template_parms_p = 0;
5335               continue;
5336             }
5337           else
5338             return NULL_TREE;
5339         }
5340     }
5341   return NULL_TREE;
5342 }
5343
5344 #if 0
5345 void
5346 set_current_level_tags_transparency (tags_transparent)
5347      int tags_transparent;
5348 {
5349   current_binding_level->tag_transparent = tags_transparent;
5350 }
5351 #endif
5352
5353 /* Given a type, find the tag that was defined for it and return the tag name.
5354    Otherwise return 0.  However, the value can never be 0
5355    in the cases in which this is used.
5356
5357    C++: If NAME is non-zero, this is the new name to install.  This is
5358    done when replacing anonymous tags with real tag names.  */
5359
5360 static tree
5361 lookup_tag_reverse (type, name)
5362      tree type;
5363      tree name;
5364 {
5365   register struct binding_level *level;
5366
5367   for (level = current_binding_level; level; level = level->level_chain)
5368     {
5369       register tree tail;
5370       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5371         {
5372           if (TREE_VALUE (tail) == type)
5373             {
5374               if (name)
5375                 TREE_PURPOSE (tail) = name;
5376               return TREE_PURPOSE (tail);
5377             }
5378         }
5379     }
5380   return NULL_TREE;
5381 }
5382 \f
5383 /* Look up NAME in the NAMESPACE.  */
5384
5385 tree
5386 lookup_namespace_name (namespace, name)
5387      tree namespace, name;
5388 {
5389   tree val;
5390   tree template_id = NULL_TREE;
5391
5392   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5393
5394   if (TREE_CODE (name) == NAMESPACE_DECL)
5395     /* This happens for A::B<int> when B is a namespace. */
5396     return name;
5397   else if (TREE_CODE (name) == TEMPLATE_DECL)
5398     {
5399       /* This happens for A::B where B is a template, and there are no
5400          template arguments.  */
5401       cp_error ("invalid use of `%D'", name);
5402       return error_mark_node;
5403     }
5404
5405   namespace = ORIGINAL_NAMESPACE (namespace);
5406
5407   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5408     {
5409       template_id = name;
5410       name = TREE_OPERAND (name, 0);
5411       if (TREE_CODE (name) == OVERLOAD)
5412         name = DECL_NAME (OVL_CURRENT (name));
5413       else if (DECL_P (name))
5414         name = DECL_NAME (name);
5415     }
5416
5417   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5418
5419   val = make_node (CPLUS_BINDING);
5420   if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5421     return error_mark_node;
5422
5423   if (BINDING_VALUE (val))
5424     {
5425       val = BINDING_VALUE (val);
5426
5427       if (template_id)
5428         {
5429           if (DECL_CLASS_TEMPLATE_P (val))
5430             val = lookup_template_class (val,
5431                                          TREE_OPERAND (template_id, 1),
5432                                          /*in_decl=*/NULL_TREE,
5433                                          /*context=*/NULL_TREE,
5434                                          /*entering_scope=*/0);
5435           else if (DECL_FUNCTION_TEMPLATE_P (val)
5436                    || TREE_CODE (val) == OVERLOAD)
5437             val = lookup_template_function (val,
5438                                             TREE_OPERAND (template_id, 1));
5439           else
5440             {
5441               cp_error ("`%D::%D' is not a template",
5442                         namespace, name);
5443               return error_mark_node;
5444             }
5445         }
5446
5447       /* If we have a single function from a using decl, pull it out.  */
5448       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5449         val = OVL_FUNCTION (val);
5450       return val;
5451     }
5452
5453   cp_error ("`%D' undeclared in namespace `%D'", name, namespace);
5454   return error_mark_node;
5455 }
5456
5457 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
5458
5459 static unsigned long
5460 typename_hash (k)
5461      hash_table_key k;
5462 {
5463   unsigned long hash;
5464   tree t;
5465
5466   t = (tree) k;
5467   hash = (((unsigned long) TYPE_CONTEXT (t))
5468           ^ ((unsigned long) DECL_NAME (TYPE_NAME (t))));
5469
5470   return hash;
5471 }
5472
5473 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
5474
5475 static boolean
5476 typename_compare (k1, k2)
5477      hash_table_key k1;
5478      hash_table_key k2;
5479 {
5480   tree t1;
5481   tree t2;
5482   tree d1;
5483   tree d2;
5484
5485   t1 = (tree) k1;
5486   t2 = (tree) k2;
5487   d1 = TYPE_NAME (t1);
5488   d2 = TYPE_NAME (t2);
5489
5490   return (DECL_NAME (d1) == DECL_NAME (d2)
5491           && same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))
5492           && ((TREE_TYPE (t1) != NULL_TREE)
5493               == (TREE_TYPE (t2) != NULL_TREE))
5494           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5495           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5496 }
5497
5498 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
5499    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
5500    is non-NULL, this type is being created by the implicit typename
5501    extension, and BASE_TYPE is a type named `t' in some base class of
5502    `T' which depends on template parameters.
5503
5504    Returns the new TYPENAME_TYPE.  */
5505
5506 tree
5507 build_typename_type (context, name, fullname, base_type)
5508      tree context;
5509      tree name;
5510      tree fullname;
5511      tree base_type;
5512 {
5513   tree t;
5514   tree d;
5515   struct hash_entry* e;
5516
5517   static struct hash_table ht;
5518
5519   if (!ht.table)
5520     {
5521       static struct hash_table *h = &ht;
5522       if (!hash_table_init (&ht, &hash_newfunc, &typename_hash,
5523                             &typename_compare))
5524         fatal ("virtual memory exhausted");
5525       ggc_add_tree_hash_table_root (&h, 1);
5526     }
5527
5528   /* Build the TYPENAME_TYPE.  */
5529   t = make_aggr_type (TYPENAME_TYPE);
5530   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5531   TYPENAME_TYPE_FULLNAME (t) = fullname;
5532   TREE_TYPE (t) = base_type;
5533
5534   /* Build the corresponding TYPE_DECL.  */
5535   d = build_decl (TYPE_DECL, name, t);
5536   TYPE_NAME (TREE_TYPE (d)) = d;
5537   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5538   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5539   DECL_ARTIFICIAL (d) = 1;
5540
5541   /* See if we already have this type.  */
5542   e = hash_lookup (&ht, t, /*create=*/false, /*copy=*/0);
5543   if (e)
5544     t = (tree) e->key;
5545   else
5546     /* Insert the type into the table.  */
5547     hash_lookup (&ht, t, /*create=*/true, /*copy=*/0);
5548
5549   return t;
5550 }
5551
5552 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
5553    unless an error occurs, in which case error_mark_node is returned.
5554    If COMPLAIN zero, don't complain about any errors that occur.  */
5555
5556 tree
5557 make_typename_type (context, name, complain)
5558      tree context, name;
5559      int complain;
5560 {
5561   tree fullname;
5562
5563   if (TYPE_P (name))
5564     {
5565       if (!(TYPE_LANG_SPECIFIC (name)
5566             && (CLASSTYPE_IS_TEMPLATE (name)
5567                 || CLASSTYPE_USE_TEMPLATE (name))))
5568         name = TYPE_IDENTIFIER (name);
5569       else
5570         /* Create a TEMPLATE_ID_EXPR for the type.  */
5571         name = build_nt (TEMPLATE_ID_EXPR,
5572                          CLASSTYPE_TI_TEMPLATE (name),
5573                          CLASSTYPE_TI_ARGS (name));
5574     }
5575   else if (TREE_CODE (name) == TYPE_DECL)
5576     name = DECL_NAME (name);
5577
5578   fullname = name;
5579
5580   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5581     {
5582       name = TREE_OPERAND (name, 0);
5583       if (TREE_CODE (name) == TEMPLATE_DECL)
5584         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5585     }
5586   if (TREE_CODE (name) != IDENTIFIER_NODE)
5587     my_friendly_abort (2000);
5588
5589   if (TREE_CODE (context) == NAMESPACE_DECL)
5590     {
5591       /* We can get here from typename_sub0 in the explicit_template_type
5592          expansion.  Just fail.  */
5593       if (complain)
5594         cp_error ("no class template named `%#T' in `%#T'",
5595                   name, context);
5596       return error_mark_node;
5597     }
5598
5599   if (! uses_template_parms (context)
5600       || currently_open_class (context))
5601     {
5602       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5603         {
5604           tree tmpl = NULL_TREE;
5605           if (IS_AGGR_TYPE (context))
5606             tmpl = lookup_field (context, name, 0, 0);
5607           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5608             {
5609               if (complain)
5610                 cp_error ("no class template named `%#T' in `%#T'",
5611                           name, context);
5612               return error_mark_node;
5613             }
5614
5615           return lookup_template_class (tmpl,
5616                                         TREE_OPERAND (fullname, 1),
5617                                         NULL_TREE, context,
5618                                         /*entering_scope=*/0);
5619         }
5620       else
5621         {
5622           tree t;
5623
5624           if (!IS_AGGR_TYPE (context))
5625             {
5626               if (complain)
5627                 cp_error ("no type named `%#T' in `%#T'", name, context);
5628               return error_mark_node;
5629             }
5630
5631           t = lookup_field (context, name, 0, 1);
5632           if (t)
5633             return TREE_TYPE (t);
5634         }
5635     }
5636
5637   /* If the CONTEXT is not a template type, then either the field is
5638      there now or its never going to be.  */
5639   if (!uses_template_parms (context))
5640     {
5641       if (complain)
5642         cp_error ("no type named `%#T' in `%#T'", name, context);
5643       return error_mark_node;
5644     }
5645
5646
5647   return build_typename_type (context, name, fullname,  NULL_TREE);
5648 }
5649
5650 /* Select the right _DECL from multiple choices. */
5651
5652 static tree
5653 select_decl (binding, flags)
5654      tree binding;
5655      int flags;
5656 {
5657   tree val;
5658   val = BINDING_VALUE (binding);
5659   if (LOOKUP_NAMESPACES_ONLY (flags))
5660     {
5661       /* We are not interested in types. */
5662       if (val && TREE_CODE (val) == NAMESPACE_DECL)
5663         return val;
5664       return NULL_TREE;
5665     }
5666
5667   /* If we could have a type and
5668      we have nothing or we need a type and have none.  */
5669   if (BINDING_TYPE (binding)
5670       && (!val || ((flags & LOOKUP_PREFER_TYPES)
5671                    && TREE_CODE (val) != TYPE_DECL)))
5672     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5673   /* Don't return non-types if we really prefer types. */
5674   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
5675            && (TREE_CODE (val) != TEMPLATE_DECL
5676                || !DECL_CLASS_TEMPLATE_P (val)))
5677     val = NULL_TREE;
5678
5679   return val;
5680 }
5681
5682 /* Unscoped lookup of a global: iterate over current namespaces,
5683    considering using-directives.  If SPACESP is non-NULL, store a list
5684    of the namespaces we've considered in it.  */
5685
5686 tree
5687 unqualified_namespace_lookup (name, flags, spacesp)
5688      tree name;
5689      int flags;
5690      tree *spacesp;
5691 {
5692   tree b = make_node (CPLUS_BINDING);
5693   tree initial = current_decl_namespace();
5694   tree scope = initial;
5695   tree siter;
5696   struct binding_level *level;
5697   tree val = NULL_TREE;
5698
5699   if (spacesp)
5700     *spacesp = NULL_TREE;
5701
5702   for (; !val; scope = CP_DECL_CONTEXT (scope))
5703     {
5704       if (spacesp)
5705         *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5706       val = binding_for_name (name, scope);
5707
5708       /* Initialize binding for this context. */
5709       BINDING_VALUE (b) = BINDING_VALUE (val);
5710       BINDING_TYPE (b) = BINDING_TYPE (val);
5711
5712       /* Add all _DECLs seen through local using-directives. */
5713       for (level = current_binding_level;
5714            !level->namespace_p;
5715            level = level->level_chain)
5716         if (!lookup_using_namespace (name, b, level->using_directives,
5717                                      scope, flags, spacesp))
5718           /* Give up because of error. */
5719           return error_mark_node;
5720
5721       /* Add all _DECLs seen through global using-directives. */
5722       /* XXX local and global using lists should work equally. */
5723       siter = initial;
5724       while (1)
5725         {
5726           if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5727                                        scope, flags, spacesp))
5728             /* Give up because of error. */
5729             return error_mark_node;
5730           if (siter == scope) break;
5731           siter = CP_DECL_CONTEXT (siter);
5732         }
5733
5734       val = select_decl (b, flags);
5735       if (scope == global_namespace)
5736         break;
5737     }
5738   return val;
5739 }
5740
5741 /* Combine prefer_type and namespaces_only into flags.  */
5742
5743 static int
5744 lookup_flags (prefer_type, namespaces_only)
5745   int prefer_type, namespaces_only;
5746 {
5747   if (namespaces_only)
5748     return LOOKUP_PREFER_NAMESPACES;
5749   if (prefer_type > 1)
5750     return LOOKUP_PREFER_TYPES;
5751   if (prefer_type > 0)
5752     return LOOKUP_PREFER_BOTH;
5753   return 0;
5754 }
5755
5756 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5757    ignore it or not.  Subroutine of lookup_name_real.  */
5758
5759 static tree
5760 qualify_lookup (val, flags)
5761      tree val;
5762      int flags;
5763 {
5764   if (val == NULL_TREE)
5765     return val;
5766   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5767     return val;
5768   if ((flags & LOOKUP_PREFER_TYPES)
5769       && (TREE_CODE (val) == TYPE_DECL
5770           || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5771               && DECL_CLASS_TEMPLATE_P (val))))
5772     return val;
5773   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5774     return NULL_TREE;
5775   return val;
5776 }
5777
5778 /* Any other BINDING overrides an implicit TYPENAME.  Warn about
5779    that.  */
5780
5781 static void
5782 warn_about_implicit_typename_lookup (typename, binding)
5783      tree typename;
5784      tree binding;
5785 {
5786   tree subtype = TREE_TYPE (TREE_TYPE (typename));
5787   tree name = DECL_NAME (typename);
5788
5789   if (! (TREE_CODE (binding) == TEMPLATE_DECL
5790          && CLASSTYPE_TEMPLATE_INFO (subtype)
5791          && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
5792       && ! (TREE_CODE (binding) == TYPE_DECL
5793             && same_type_p (TREE_TYPE (binding), subtype)))
5794     {
5795       cp_warning ("lookup of `%D' finds `%#D'",
5796                   name, binding);
5797       cp_warning ("  instead of `%D' from dependent base class",
5798                   typename);
5799       cp_warning ("  (use `typename %T::%D' if that's what you meant)",
5800                   constructor_name (current_class_type), name);
5801     }
5802 }
5803
5804 /* Look up NAME in the current binding level and its superiors in the
5805    namespace of variables, functions and typedefs.  Return a ..._DECL
5806    node of some kind representing its definition if there is only one
5807    such declaration, or return a TREE_LIST with all the overloaded
5808    definitions if there are many, or return 0 if it is undefined.
5809
5810    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5811    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5812    If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5813    Otherwise we prefer non-TYPE_DECLs.
5814
5815    If NONCLASS is non-zero, we don't look for the NAME in class scope,
5816    using IDENTIFIER_CLASS_VALUE.  */
5817
5818 static tree
5819 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
5820      tree name;
5821      int prefer_type, nonclass, namespaces_only;
5822 {
5823   tree t;
5824   tree val = NULL_TREE;
5825   int yylex = 0;
5826   tree from_obj = NULL_TREE;
5827   int flags;
5828   int val_is_implicit_typename = 0;
5829
5830   /* Hack: copy flag set by parser, if set. */
5831   if (only_namespace_names)
5832     namespaces_only = 1;
5833
5834   if (prefer_type == -2)
5835     {
5836       extern int looking_for_typename;
5837       tree type = NULL_TREE;
5838
5839       yylex = 1;
5840       prefer_type = looking_for_typename;
5841
5842       flags = lookup_flags (prefer_type, namespaces_only);
5843       /* If the next thing is '<', class templates are types. */
5844       if (looking_for_template)
5845         flags |= LOOKUP_TEMPLATES_EXPECTED;
5846
5847       /* std:: becomes :: for now.  */
5848       if (got_scope == std_node)
5849         got_scope = void_type_node;
5850
5851       if (got_scope)
5852         type = got_scope;
5853       else if (got_object != error_mark_node)
5854         type = got_object;
5855
5856       if (type)
5857         {
5858           if (type == error_mark_node)
5859             return error_mark_node;
5860           if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
5861             type = TREE_TYPE (type);
5862
5863           if (TYPE_P (type))
5864             type = complete_type (type);
5865
5866           if (TREE_CODE (type) == VOID_TYPE)
5867             type = global_namespace;
5868           if (TREE_CODE (type) == NAMESPACE_DECL)
5869             {
5870               val = make_node (CPLUS_BINDING);
5871               flags |= LOOKUP_COMPLAIN;
5872               if (!qualified_lookup_using_namespace (name, type, val, flags))
5873                 return NULL_TREE;
5874               val = select_decl (val, flags);
5875             }
5876           else if (! IS_AGGR_TYPE (type)
5877                    || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5878                    || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM
5879                    || TREE_CODE (type) == TYPENAME_TYPE)
5880             /* Someone else will give an error about this if needed.  */
5881             val = NULL_TREE;
5882           else if (type == current_class_type)
5883             val = IDENTIFIER_CLASS_VALUE (name);
5884           else
5885             {
5886               val = lookup_member (type, name, 0, prefer_type);
5887               type_access_control (type, val);
5888             }
5889         }
5890       else
5891         val = NULL_TREE;
5892
5893       if (got_scope)
5894         goto done;
5895       else if (got_object && val)
5896         from_obj = val;
5897     }
5898   else
5899     {
5900       flags = lookup_flags (prefer_type, namespaces_only);
5901       /* If we're not parsing, we need to complain. */
5902       flags |= LOOKUP_COMPLAIN;
5903     }
5904
5905   /* First, look in non-namespace scopes.  */
5906
5907   if (current_class_type == NULL_TREE)
5908     nonclass = 1;
5909
5910   for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
5911     {
5912       tree binding;
5913
5914       if (!LOCAL_BINDING_P (t) && nonclass)
5915         /* We're not looking for class-scoped bindings, so keep going.  */
5916         continue;
5917
5918       /* If this is the kind of thing we're looking for, we're done.  */
5919       if (qualify_lookup (BINDING_VALUE (t), flags))
5920         binding = BINDING_VALUE (t);
5921       else if ((flags & LOOKUP_PREFER_TYPES)
5922                && qualify_lookup (BINDING_TYPE (t), flags))
5923         binding = BINDING_TYPE (t);
5924       else
5925         binding = NULL_TREE;
5926
5927       /* Handle access control on types from enclosing or base classes.  */
5928       if (binding && ! yylex
5929           && BINDING_LEVEL (t) && BINDING_LEVEL (t)->parm_flag == 2)
5930         type_access_control (BINDING_LEVEL (t)->this_class, binding);
5931
5932       if (binding
5933           && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
5934         {
5935           if (val_is_implicit_typename && !yylex)
5936             warn_about_implicit_typename_lookup (val, binding);
5937           val = binding;
5938           val_is_implicit_typename
5939             = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
5940           if (!val_is_implicit_typename)
5941             break;
5942         }
5943     }
5944
5945   /* Now lookup in namespace scopes.  */
5946   if (!val || val_is_implicit_typename)
5947     {
5948       t = unqualified_namespace_lookup (name, flags, 0);
5949       if (t)
5950         {
5951           if (val_is_implicit_typename && !yylex)
5952             warn_about_implicit_typename_lookup (val, t);
5953           val = t;
5954         }
5955     }
5956
5957  done:
5958   if (val)
5959     {
5960       /* This should only warn about types used in qualified-ids.  */
5961       if (from_obj && from_obj != val)
5962         {
5963           if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
5964               && TREE_CODE (val) == TYPE_DECL
5965               && TREE_TYPE (from_obj) != TREE_TYPE (val))
5966             {
5967               cp_pedwarn ("lookup of `%D' in the scope of `%#T' (`%#T')",
5968                           name, got_object, TREE_TYPE (from_obj));
5969               cp_pedwarn ("  does not match lookup in the current scope (`%#T')",
5970                           TREE_TYPE (val));
5971             }
5972
5973           /* We don't change val to from_obj if got_object depends on
5974              template parms because that breaks implicit typename for
5975              destructor calls.  */
5976           if (! uses_template_parms (got_object))
5977             val = from_obj;
5978         }
5979
5980       /* If we have a single function from a using decl, pull it out.  */
5981       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5982         val = OVL_FUNCTION (val);
5983     }
5984   else if (from_obj)
5985     val = from_obj;
5986
5987   return val;
5988 }
5989
5990 tree
5991 lookup_name_nonclass (name)
5992      tree name;
5993 {
5994   return lookup_name_real (name, 0, 1, 0);
5995 }
5996
5997 tree
5998 lookup_function_nonclass (name, args)
5999      tree name;
6000      tree args;
6001 {
6002   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
6003 }
6004
6005 tree
6006 lookup_name_namespace_only (name)
6007      tree name;
6008 {
6009   /* type-or-namespace, nonclass, namespace_only */
6010   return lookup_name_real (name, 1, 1, 1);
6011 }
6012
6013 tree
6014 lookup_name (name, prefer_type)
6015      tree name;
6016      int prefer_type;
6017 {
6018   return lookup_name_real (name, prefer_type, 0, 0);
6019 }
6020
6021 /* Similar to `lookup_name' but look only in the innermost non-class
6022    binding level.  */
6023
6024 tree
6025 lookup_name_current_level (name)
6026      tree name;
6027 {
6028   struct binding_level *b;
6029   tree t = NULL_TREE;
6030
6031   b = current_binding_level;
6032   while (b->parm_flag == 2)
6033     b = b->level_chain;
6034
6035   if (b->namespace_p)
6036     {
6037       t = IDENTIFIER_NAMESPACE_VALUE (name);
6038
6039       /* extern "C" function() */
6040       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
6041         t = TREE_VALUE (t);
6042     }
6043   else if (IDENTIFIER_BINDING (name)
6044            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
6045     {
6046       while (1)
6047         {
6048           if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
6049             return IDENTIFIER_VALUE (name);
6050
6051           if (b->keep == 2)
6052             b = b->level_chain;
6053           else
6054             break;
6055         }
6056     }
6057
6058   return t;
6059 }
6060
6061 /* Like lookup_name_current_level, but for types.  */
6062
6063 tree
6064 lookup_type_current_level (name)
6065      tree name;
6066 {
6067   register tree t = NULL_TREE;
6068
6069   my_friendly_assert (! current_binding_level->namespace_p, 980716);
6070
6071   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
6072       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
6073     {
6074       struct binding_level *b = current_binding_level;
6075       while (1)
6076         {
6077           if (purpose_member (name, b->type_shadowed))
6078             return REAL_IDENTIFIER_TYPE_VALUE (name);
6079           if (b->keep == 2)
6080             b = b->level_chain;
6081           else
6082             break;
6083         }
6084     }
6085
6086   return t;
6087 }
6088
6089 void
6090 begin_only_namespace_names ()
6091 {
6092   only_namespace_names = 1;
6093 }
6094
6095 void
6096 end_only_namespace_names ()
6097 {
6098   only_namespace_names = 0;
6099 }
6100 \f
6101 /* Push the declarations of builtin types into the namespace.
6102    RID_INDEX, if < CP_RID_MAX is the index of the builtin type
6103    in the array RID_POINTERS.  NAME is the name used when looking
6104    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
6105
6106 static void
6107 record_builtin_type (rid_index, name, type)
6108      enum rid rid_index;
6109      const char *name;
6110      tree type;
6111 {
6112   tree rname = NULL_TREE, tname = NULL_TREE;
6113   tree tdecl = NULL_TREE;
6114
6115   if ((int) rid_index < (int) CP_RID_MAX)
6116     rname = ridpointers[(int) rid_index];
6117   if (name)
6118     tname = get_identifier (name);
6119
6120   TYPE_BUILT_IN (type) = 1;
6121
6122   if (tname)
6123     {
6124       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
6125       set_identifier_type_value (tname, NULL_TREE);
6126       if ((int) rid_index < (int) CP_RID_MAX)
6127         /* Built-in types live in the global namespace. */
6128         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
6129     }
6130   if (rname != NULL_TREE)
6131     {
6132       if (tname != NULL_TREE)
6133         {
6134           set_identifier_type_value (rname, NULL_TREE);
6135           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
6136         }
6137       else
6138         {
6139           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
6140           set_identifier_type_value (rname, NULL_TREE);
6141         }
6142     }
6143 }
6144
6145 /* Record one of the standard Java types.
6146  * Declare it as having the given NAME.
6147  * If SIZE > 0, it is the size of one of the integral types;
6148  * otherwise it is the negative of the size of one of the other types.  */
6149
6150 static tree
6151 record_builtin_java_type (name, size)
6152      const char *name;
6153      int size;
6154 {
6155   tree type, decl;
6156   if (size > 0)
6157     type = make_signed_type (size);
6158   else if (size > -32)
6159     { /* "__java_char" or ""__java_boolean". */
6160       type = make_unsigned_type (-size);
6161       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6162     }
6163   else
6164     { /* "__java_float" or ""__java_double". */
6165       type = make_node (REAL_TYPE);
6166       TYPE_PRECISION (type) = - size;
6167       layout_type (type);
6168     }
6169   record_builtin_type (CP_RID_MAX, name, type);
6170   decl = TYPE_NAME (type);
6171
6172   /* Suppress generate debug symbol entries for these types,
6173      since for normal C++ they are just clutter.
6174      However, push_lang_context undoes this if extern "Java" is seen. */
6175   DECL_IGNORED_P (decl) = 1;
6176
6177   TYPE_FOR_JAVA (type) = 1;
6178   return type;
6179 }
6180
6181 /* Push a type into the namespace so that the back-ends ignore it. */
6182
6183 static void
6184 record_unknown_type (type, name)
6185      tree type;
6186      const char *name;
6187 {
6188   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
6189   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
6190   DECL_IGNORED_P (decl) = 1;
6191   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6192   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
6193   TYPE_ALIGN (type) = 1;
6194   TYPE_USER_ALIGN (type) = 0;
6195   TYPE_MODE (type) = TYPE_MODE (void_type_node);
6196 }
6197
6198 /* An string for which we should create an IDENTIFIER_NODE at
6199    startup.  */
6200
6201 typedef struct predefined_identifier
6202 {
6203   /* The name of the identifier.  */
6204   const char *name;
6205   /* The place where the IDENTIFIER_NODE should be stored.  */
6206   tree *node;
6207   /* Non-zero if this is the name of a constructor or destructor.  */
6208   int ctor_or_dtor_p;
6209 } predefined_identifier;
6210
6211 /* Create all the predefined identifiers.  */
6212
6213 static void
6214 initialize_predefined_identifiers ()
6215 {
6216   struct predefined_identifier *pid;
6217
6218   /* A table of identifiers to create at startup.  */
6219   static predefined_identifier predefined_identifiers[] = {
6220     { "C++", &lang_name_cplusplus, 0 },
6221     { "C", &lang_name_c, 0 },
6222     { "Java", &lang_name_java, 0 },
6223     { CTOR_NAME, &ctor_identifier, 1 },
6224     { "__base_ctor", &base_ctor_identifier, 1 },
6225     { "__comp_ctor", &complete_ctor_identifier, 1 },
6226     { DTOR_NAME, &dtor_identifier, 1 },
6227     { "__comp_dtor", &complete_dtor_identifier, 1 },
6228     { "__base_dtor", &base_dtor_identifier, 1 },
6229     { "__deleting_dtor", &deleting_dtor_identifier, 1 },
6230     { VTABLE_DELTA2_NAME, &delta2_identifier, 0 },
6231     { VTABLE_DELTA_NAME, &delta_identifier, 0 },
6232     { IN_CHARGE_NAME, &in_charge_identifier, 0 },
6233     { VTABLE_INDEX_NAME, &index_identifier, 0 },
6234     { "nelts", &nelts_identifier, 0 },
6235     { THIS_NAME, &this_identifier, 0 },
6236     { VTABLE_PFN_NAME, &pfn_identifier, 0 },
6237     { "__pfn_or_delta2", &pfn_or_delta2_identifier, 0 },
6238     { "_vptr", &vptr_identifier, 0 },
6239     { "__cp_push_exception", &cp_push_exception_identifier, 0 },
6240     { "__vtt_parm", &vtt_parm_identifier, 0 },
6241     { "std", &std_identifier, 0 },
6242     { NULL, NULL, 0 }
6243   };
6244
6245   for (pid = predefined_identifiers; pid->name; ++pid)
6246     {
6247       *pid->node = get_identifier (pid->name);
6248       if (pid->ctor_or_dtor_p)
6249         IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
6250     }
6251 }
6252
6253 /* Create the predefined scalar types of C,
6254    and some nodes representing standard constants (0, 1, (void *)0).
6255    Initialize the global binding level.
6256    Make definitions for built-in primitive functions.  */
6257
6258 void
6259 init_decl_processing ()
6260 {
6261   tree fields[20];
6262   int wchar_type_size;
6263   tree array_domain_type;
6264
6265   /* Check to see that the user did not specify an invalid combination
6266      of command-line options.  */
6267   if (flag_new_abi && !flag_vtable_thunks)
6268     fatal ("the new ABI requires vtable thunks");
6269
6270   /* Create all the identifiers we need.  */
6271   initialize_predefined_identifiers ();
6272
6273   /* Let the back-end now how to save and restore language-specific
6274      per-function globals.  */
6275   init_lang_status = &push_cp_function_context;
6276   free_lang_status = &pop_cp_function_context;
6277   mark_lang_status = &mark_cp_function_context;
6278
6279   cp_parse_init ();
6280   init_decl2 ();
6281   init_pt ();
6282
6283   /* Create the global variables.  */
6284   push_to_top_level ();
6285
6286   /* Enter the global namespace. */
6287   my_friendly_assert (global_namespace == NULL_TREE, 375);
6288   push_namespace (get_identifier ("::"));
6289   global_namespace = current_namespace;
6290   current_lang_name = NULL_TREE;
6291
6292   /* Adjust various flags based on command-line settings.  */
6293   if (! flag_permissive && ! pedantic)
6294     flag_pedantic_errors = 1;
6295   if (!flag_no_inline)
6296     flag_inline_trees = 1;
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 (!DECL_NAME (decl))
7847     return;
7848
7849   if (current_binding_level->is_for_scope)
7850     {
7851       struct binding_level *outer
7852         = current_binding_level->level_chain;
7853
7854       /* Check to see if the same name is already bound at the outer
7855          level, either because it was directly declared, or because a
7856          dead for-decl got preserved.  In either case, the code would
7857          not have been valid under the ARM scope rules, so clear
7858          is_for_scope for the current_binding_level.
7859
7860          Otherwise, we need to preserve the temp slot for decl to last
7861          into the outer binding level.  */
7862
7863       tree outer_binding
7864         = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
7865
7866       if (outer_binding && BINDING_LEVEL (outer_binding) == outer
7867           && (TREE_CODE (BINDING_VALUE (outer_binding))
7868               == VAR_DECL)
7869           && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
7870         {
7871           BINDING_VALUE (outer_binding)
7872             = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
7873           current_binding_level->is_for_scope = 0;
7874         }
7875       else if (DECL_IN_MEMORY_P (decl))
7876         preserve_temp_slots (DECL_RTL (decl));
7877     }
7878 }
7879
7880 /* Generate code to initialize DECL (a local variable).  */
7881
7882 void
7883 initialize_local_var (decl, init, flags)
7884      tree decl;
7885      tree init;
7886      int flags;
7887 {
7888   tree type = TREE_TYPE (decl);
7889
7890   /* If the type is bogus, don't bother initializing the variable.  */
7891   if (type == error_mark_node)
7892     return;
7893
7894   if (DECL_SIZE (decl) == NULL_TREE && !TREE_STATIC (decl))
7895     {
7896       /* If we used it already as memory, it must stay in memory.  */
7897       DECL_INITIAL (decl) = NULL_TREE;
7898       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
7899     }
7900
7901   /* Local statics are handled differently from ordinary automatic
7902      variables.  */
7903   if (TREE_STATIC (decl))
7904     {
7905       if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7906           || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7907         expand_static_init (decl, init);
7908       return;
7909     }
7910
7911   if (DECL_SIZE (decl) && type != error_mark_node)
7912     {
7913       int already_used;
7914
7915       /* Compute and store the initial value.  */
7916       already_used = TREE_USED (decl) || TREE_USED (type);
7917
7918       if (init || TYPE_NEEDS_CONSTRUCTING (type))
7919         {
7920           int saved_stmts_are_full_exprs_p;
7921
7922           emit_line_note (DECL_SOURCE_FILE (decl),
7923                           DECL_SOURCE_LINE (decl));
7924           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
7925           current_stmt_tree->stmts_are_full_exprs_p = 1;
7926           if (building_stmt_tree ())
7927             finish_expr_stmt (build_aggr_init (decl, init, flags));
7928           else
7929             genrtl_expr_stmt (build_aggr_init (decl, init, flags));
7930           current_stmt_tree->stmts_are_full_exprs_p = saved_stmts_are_full_exprs_p;
7931         }
7932
7933       /* Set this to 0 so we can tell whether an aggregate which was
7934          initialized was ever used.  Don't do this if it has a
7935          destructor, so we don't complain about the 'resource
7936          allocation is initialization' idiom.  Now set
7937          attribute((unused)) on types so decls of that type will be
7938          marked used. (see TREE_USED, above.)  */
7939       if (TYPE_NEEDS_CONSTRUCTING (type)
7940           && ! already_used
7941           && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
7942           && DECL_NAME (decl))
7943         TREE_USED (decl) = 0;
7944       else if (already_used)
7945         TREE_USED (decl) = 1;
7946     }
7947 }
7948
7949 /* Generate code to destroy DECL (a local variable).  */
7950
7951 static void
7952 destroy_local_var (decl)
7953      tree decl;
7954 {
7955   tree type = TREE_TYPE (decl);
7956   tree cleanup;
7957
7958   /* Only variables get cleaned up.  */
7959   if (TREE_CODE (decl) != VAR_DECL)
7960     return;
7961
7962   /* And only things with destructors need cleaning up.  */
7963   if (type == error_mark_node
7964       || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
7965     return;
7966
7967   if (TREE_CODE (decl) == VAR_DECL &&
7968       (DECL_EXTERNAL (decl) || TREE_STATIC (decl)))
7969     /* We don't clean up things that aren't defined in this
7970        translation unit, or that need a static cleanup.  The latter
7971        are handled by finish_file.  */
7972     return;
7973
7974   /* Compute the cleanup.  */
7975   cleanup = maybe_build_cleanup (decl);
7976
7977   /* Record the cleanup required for this declaration.  */
7978   if (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node
7979       && cleanup)
7980     finish_decl_cleanup (decl, cleanup);
7981 }
7982
7983 /* Finish processing of a declaration;
7984    install its line number and initial value.
7985    If the length of an array type is not known before,
7986    it must be determined now, from the initial value, or it is an error.
7987
7988    INIT holds the value of an initializer that should be allowed to escape
7989    the normal rules.
7990
7991    FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
7992    if the (init) syntax was used.  */
7993
7994 void
7995 cp_finish_decl (decl, init, asmspec_tree, flags)
7996      tree decl, init;
7997      tree asmspec_tree;
7998      int flags;
7999 {
8000   register tree type;
8001   tree ttype = NULL_TREE;
8002   const char *asmspec = NULL;
8003   int was_readonly = 0;
8004
8005   if (! decl)
8006     {
8007       if (init)
8008         error ("assignment (not initialization) in declaration");
8009       return;
8010     }
8011
8012   /* If a name was specified, get the string.  */
8013   if (asmspec_tree)
8014       asmspec = TREE_STRING_POINTER (asmspec_tree);
8015
8016   if (init && TREE_CODE (init) == NAMESPACE_DECL)
8017     {
8018       cp_error ("cannot initialize `%D' to namespace `%D'",
8019                 decl, init);
8020       init = NULL_TREE;
8021     }
8022
8023   if (current_class_type
8024       && CP_DECL_CONTEXT (decl) == current_class_type
8025       && TYPE_BEING_DEFINED (current_class_type)
8026       && (DECL_INITIAL (decl) || init))
8027     DECL_DEFINED_IN_CLASS_P (decl) = 1;
8028
8029   if (TREE_CODE (decl) == VAR_DECL
8030       && DECL_CONTEXT (decl)
8031       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
8032       && DECL_CONTEXT (decl) != current_namespace
8033       && init)
8034     {
8035       /* Leave the namespace of the object. */
8036       pop_decl_namespace ();
8037     }
8038
8039   type = TREE_TYPE (decl);
8040
8041   if (type == error_mark_node)
8042     return;
8043
8044   /* Add this declaration to the statement-tree.  */
8045   if (building_stmt_tree () && at_function_scope_p ())
8046     add_decl_stmt (decl);
8047
8048   if (TYPE_HAS_MUTABLE_P (type))
8049     TREE_READONLY (decl) = 0;
8050
8051   if (processing_template_decl)
8052     {
8053       if (init && DECL_INITIAL (decl))
8054         DECL_INITIAL (decl) = init;
8055       goto finish_end0;
8056     }
8057
8058   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
8059   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
8060
8061   /* Take care of TYPE_DECLs up front.  */
8062   if (TREE_CODE (decl) == TYPE_DECL)
8063     {
8064       if (init && DECL_INITIAL (decl))
8065         {
8066           /* typedef foo = bar; store the type of bar as the type of foo.  */
8067           TREE_TYPE (decl) = type = TREE_TYPE (init);
8068           DECL_INITIAL (decl) = init = NULL_TREE;
8069         }
8070       if (type != error_mark_node
8071           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
8072         {
8073           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
8074             cp_warning ("shadowing previous type declaration of `%#D'", decl);
8075           set_identifier_type_value (DECL_NAME (decl), type);
8076           CLASSTYPE_GOT_SEMICOLON (type) = 1;
8077         }
8078       GNU_xref_decl (current_function_decl, decl);
8079
8080       /* If we have installed this as the canonical typedef for this
8081          type, and that type has not been defined yet, delay emitting
8082          the debug information for it, as we will emit it later.  */
8083       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
8084           && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
8085         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
8086
8087       rest_of_decl_compilation (decl, NULL_PTR,
8088                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
8089       goto finish_end;
8090     }
8091
8092   if (TREE_CODE (decl) != FUNCTION_DECL)
8093     ttype = target_type (type);
8094
8095   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
8096       && TYPE_NEEDS_CONSTRUCTING (type))
8097     {
8098       /* Currently, GNU C++ puts constants in text space, making them
8099          impossible to initialize.  In the future, one would hope for
8100          an operating system which understood the difference between
8101          initialization and the running of a program.  */
8102       was_readonly = 1;
8103       TREE_READONLY (decl) = 0;
8104     }
8105
8106   if (TREE_CODE (decl) == FIELD_DECL && asmspec)
8107     {
8108       /* This must override the asm specifier which was placed by
8109          grokclassfn.  Lay this out fresh.  */
8110       DECL_RTL (TREE_TYPE (decl)) = NULL_RTX;
8111       DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
8112       make_decl_rtl (decl, asmspec, 0);
8113     }
8114
8115   /* Deduce size of array from initialization, if not already known.  */
8116   maybe_deduce_size_from_array_init (decl, init);
8117   init = check_initializer (decl, init);
8118
8119   GNU_xref_decl (current_function_decl, decl);
8120
8121   if (TREE_CODE (decl) == VAR_DECL)
8122     layout_var_decl (decl);
8123
8124   /* Output the assembler code and/or RTL code for variables and functions,
8125      unless the type is an undefined structure or union.
8126      If not, it will get done when the type is completed.  */
8127   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
8128       || TREE_CODE (decl) == RESULT_DECL)
8129     {
8130       if (TREE_CODE (decl) == VAR_DECL)
8131         maybe_commonize_var (decl);
8132
8133       make_rtl_for_nonlocal_decl (decl, init, asmspec);
8134
8135       if (TREE_CODE (type) == FUNCTION_TYPE
8136           || TREE_CODE (type) == METHOD_TYPE)
8137         abstract_virtuals_error (decl,
8138                                  strip_array_types (TREE_TYPE (type)));
8139       else
8140         abstract_virtuals_error (decl, strip_array_types (type));
8141
8142       if (TREE_CODE (decl) == FUNCTION_DECL)
8143         ;
8144       else if (DECL_EXTERNAL (decl)
8145                && ! (DECL_LANG_SPECIFIC (decl)
8146                      && DECL_NOT_REALLY_EXTERN (decl)))
8147         {
8148           if (init)
8149             DECL_INITIAL (decl) = init;
8150         }
8151       else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
8152         {
8153           /* This is a local declaration.  */
8154           if (doing_semantic_analysis_p ())
8155             maybe_inject_for_scope_var (decl);
8156           /* Initialize the local variable.  But, if we're building a
8157              statement-tree, we'll do the initialization when we
8158              expand the tree.  */
8159           if (processing_template_decl)
8160             {
8161               if (init || DECL_INITIAL (decl) == error_mark_node)
8162                 DECL_INITIAL (decl) = init;
8163             }
8164           else
8165             {
8166               /* If we're not building RTL, then we need to do so
8167                  now.  */
8168               if (!building_stmt_tree ())
8169                 emit_local_var (decl);
8170               /* Initialize the variable.  */
8171               initialize_local_var (decl, init, flags);
8172               /* Clean up the variable.  */
8173               destroy_local_var (decl);
8174             }
8175         }
8176       else if (TREE_STATIC (decl) && type != error_mark_node)
8177         {
8178           /* Cleanups for static variables are handled by `finish_file'.  */
8179           if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
8180               || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8181             expand_static_init (decl, init);
8182         }
8183     finish_end0:
8184
8185       /* Undo call to `pushclass' that was done in `start_decl'
8186          due to initialization of qualified member variable.
8187          I.e., Foo::x = 10;  */
8188       {
8189         tree context = CP_DECL_CONTEXT (decl);
8190         if (context
8191             && TYPE_P (context)
8192             && (TREE_CODE (decl) == VAR_DECL
8193                 /* We also have a pushclass done that we need to undo here
8194                    if we're at top level and declare a method.  */
8195                 || TREE_CODE (decl) == FUNCTION_DECL)
8196             /* If size hasn't been set, we're still defining it,
8197                and therefore inside the class body; don't pop
8198                the binding level..  */
8199             && COMPLETE_TYPE_P (context)
8200             && context == current_class_type)
8201           pop_nested_class ();
8202       }
8203     }
8204
8205  finish_end:
8206
8207   if (was_readonly)
8208     TREE_READONLY (decl) = 1;
8209 }
8210
8211 /* This is here for a midend callback from c-common.c */
8212
8213 void
8214 finish_decl (decl, init, asmspec_tree)
8215      tree decl, init;
8216      tree asmspec_tree;
8217 {
8218   cp_finish_decl (decl, init, asmspec_tree, 0);
8219 }
8220
8221 /* Returns a declaration for a VAR_DECL as if:
8222
8223      extern "C" TYPE NAME;
8224
8225    had been seen.  Used to create compiler-generated global
8226    variables.  */
8227
8228 tree
8229 declare_global_var (name, type)
8230      tree name;
8231      tree type;
8232 {
8233   tree decl;
8234
8235   push_to_top_level ();
8236   decl = build_decl (VAR_DECL, name, type);
8237   TREE_PUBLIC (decl) = 1;
8238   DECL_EXTERNAL (decl) = 1;
8239   DECL_ARTIFICIAL (decl) = 1;
8240   pushdecl (decl);
8241   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
8242   pop_from_top_level ();
8243
8244   return decl;
8245 }
8246
8247 /* Returns a pointer to the `atexit' function.  Note that if
8248    FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
8249    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
8250
8251 static tree
8252 get_atexit_node ()
8253 {
8254   tree atexit_fndecl;
8255   tree arg_types;
8256   tree fn_type;
8257   tree fn_ptr_type;
8258   const char *name;
8259
8260   if (atexit_node)
8261     return atexit_node;
8262
8263   if (flag_use_cxa_atexit)
8264     {
8265       /* The declaration for `__cxa_atexit' is:
8266
8267            int __cxa_atexit (void (*)(void *), void *, void *)
8268
8269          We build up the argument types and then then function type
8270          itself.  */
8271
8272       /* First, build the pointer-to-function type for the first
8273          argument.  */
8274       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8275       fn_type = build_function_type (void_type_node, arg_types);
8276       fn_ptr_type = build_pointer_type (fn_type);
8277       /* Then, build the rest of the argument types.  */
8278       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8279       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
8280       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
8281       /* And the final __cxa_atexit type.  */
8282       fn_type = build_function_type (integer_type_node, arg_types);
8283       fn_ptr_type = build_pointer_type (fn_type);
8284       name = "__cxa_atexit";
8285     }
8286   else
8287     {
8288       /* The declaration for `atexit' is:
8289
8290            int atexit (void (*)());
8291
8292          We build up the argument types and then then function type
8293          itself.  */
8294       fn_type = build_function_type (void_type_node, void_list_node);
8295       fn_ptr_type = build_pointer_type (fn_type);
8296       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
8297       /* Build the final atexit type.  */
8298       fn_type = build_function_type (integer_type_node, arg_types);
8299       name = "atexit";
8300     }
8301
8302   /* Now, build the function declaration.  */
8303   push_lang_context (lang_name_c);
8304   atexit_fndecl = build_library_fn_ptr (name, fn_type);
8305   mark_used (atexit_fndecl);
8306   pop_lang_context ();
8307   atexit_node = default_conversion (atexit_fndecl);
8308
8309   return atexit_node;
8310 }
8311
8312 /* Returns the __dso_handle VAR_DECL.  */
8313
8314 static tree
8315 get_dso_handle_node ()
8316 {
8317   if (dso_handle_node)
8318     return dso_handle_node;
8319
8320   /* Declare the variable.  */
8321   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8322                                         ptr_type_node);
8323
8324   return dso_handle_node;
8325 }
8326
8327 /* Begin a new function with internal linkage whose job will be simply
8328    to destroy some particular variable.  */
8329
8330 static tree
8331 start_cleanup_fn ()
8332 {
8333   static int counter = 0;
8334   int old_interface_unknown = interface_unknown;
8335   char name[32];
8336   tree parmtypes;
8337   tree fntype;
8338   tree fndecl;
8339
8340   push_to_top_level ();
8341
8342   /* No need to mangle this.  */
8343   push_lang_context (lang_name_c);
8344
8345   interface_unknown = 1;
8346
8347   /* Build the parameter-types.  */
8348   parmtypes = void_list_node;
8349   /* Functions passed to __cxa_atexit take an additional parameter.
8350      We'll just ignore it.  After we implement the new calling
8351      convention for destructors, we can eliminate the use of
8352      additional cleanup functions entirely in the -fnew-abi case.  */
8353   if (flag_use_cxa_atexit)
8354     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8355   /* Build the function type itself.  */
8356   fntype = build_function_type (void_type_node, parmtypes);
8357   /* Build the name of the function.  */
8358   sprintf (name, "__tcf_%d", counter++);
8359   /* Build the function declaration.  */
8360   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8361   /* It's a function with internal linkage, generated by the
8362      compiler.  */
8363   TREE_PUBLIC (fndecl) = 0;
8364   DECL_ARTIFICIAL (fndecl) = 1;
8365   /* Make the function `inline' so that it is only emitted if it is
8366      actually needed.  It is unlikely that it will be inlined, since
8367      it is only called via a function pointer, but we avoid unncessary
8368      emissions this way.  */
8369   DECL_INLINE (fndecl) = 1;
8370   /* Build the parameter.  */
8371   if (flag_use_cxa_atexit)
8372     {
8373       tree parmdecl;
8374
8375       parmdecl = build_decl (PARM_DECL, NULL_TREE, ptr_type_node);
8376       DECL_CONTEXT (parmdecl) = fndecl;
8377       DECL_ARG_TYPE (parmdecl) = ptr_type_node;
8378       TREE_USED (parmdecl) = 1;
8379       DECL_ARGUMENTS (fndecl) = parmdecl;
8380     }
8381
8382   pushdecl (fndecl);
8383   start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8384   do_pushlevel ();
8385
8386   interface_unknown = old_interface_unknown;
8387
8388   pop_lang_context ();
8389
8390   return current_function_decl;
8391 }
8392
8393 /* Finish the cleanup function begun by start_cleanup_fn.  */
8394
8395 static void
8396 end_cleanup_fn ()
8397 {
8398   do_poplevel ();
8399
8400   expand_body (finish_function (0));
8401
8402   pop_from_top_level ();
8403 }
8404
8405 /* Generate code to handle the destruction of DECL, an object with
8406    static storage duration.  */
8407
8408 void
8409 register_dtor_fn (decl)
8410      tree decl;
8411 {
8412   tree cleanup;
8413   tree compound_stmt;
8414   tree args;
8415   tree fcall;
8416
8417   int saved_flag_access_control;
8418
8419   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8420     return;
8421
8422   /* Call build_cleanup before we enter the anonymous function so that
8423      any access checks will be done relative to the current scope,
8424      rather than the scope of the anonymous function.  */
8425   build_cleanup (decl);
8426
8427   /* Now start the function.  */
8428   cleanup = start_cleanup_fn ();
8429
8430   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
8431      to the original function, rather than the anonymous one.  That
8432      will make the back-end think that nested functions are in use,
8433      which causes confusion.  */
8434   saved_flag_access_control = flag_access_control;
8435   flag_access_control = 0;
8436   fcall = build_cleanup (decl);
8437   flag_access_control = saved_flag_access_control;
8438
8439   /* Create the body of the anonymous function.  */
8440   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8441   finish_expr_stmt (fcall);
8442   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8443   end_cleanup_fn ();
8444
8445   /* Call atexit with the cleanup function.  */
8446   mark_addressable (cleanup);
8447   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8448   if (flag_use_cxa_atexit)
8449     {
8450       args = tree_cons (NULL_TREE, get_dso_handle_node (), NULL_TREE);
8451       args = tree_cons (NULL_TREE, null_pointer_node, args);
8452       args = tree_cons (NULL_TREE, cleanup, args);
8453     }
8454   else
8455     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8456   finish_expr_stmt (build_function_call (get_atexit_node (), args));
8457 }
8458
8459 void
8460 expand_static_init (decl, init)
8461      tree decl;
8462      tree init;
8463 {
8464   tree oldstatic = value_member (decl, static_aggregates);
8465
8466   if (oldstatic)
8467     {
8468       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8469         cp_error ("multiple initializations given for `%D'", decl);
8470     }
8471   else if (! toplevel_bindings_p ())
8472     {
8473       /* Emit code to perform this initialization but once.  */
8474       tree if_stmt;
8475       tree then_clause;
8476       tree assignment;
8477       tree guard;
8478       tree guard_init;
8479
8480       /* Emit code to perform this initialization but once.  This code
8481          looks like:
8482
8483            static int guard = 0;
8484            if (!guard) {
8485              // Do initialization.
8486              guard = 1;
8487              // Register variable for destruction at end of program.
8488            }
8489
8490          Note that the `temp' variable is only set to 1 *after* the
8491          initialization is complete.  This ensures that an exception,
8492          thrown during the construction, will cause the variable to
8493          reinitialized when we pass through this code again, as per:
8494
8495            [stmt.dcl]
8496
8497            If the initialization exits by throwing an exception, the
8498            initialization is not complete, so it will be tried again
8499            the next time control enters the declaration.
8500
8501          In theory, this process should be thread-safe, too; multiple
8502          threads should not be able to initialize the variable more
8503          than once.  We don't yet attempt to ensure thread-safety.  */
8504
8505       /* Create the guard variable.  */
8506       guard = get_guard (decl);
8507
8508       /* Begin the conditional initialization.  */
8509       if_stmt = begin_if_stmt ();
8510       finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
8511       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8512
8513       /* Do the initialization itself.  */
8514       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8515           || (init && TREE_CODE (init) == TREE_LIST))
8516         assignment = build_aggr_init (decl, init, 0);
8517       else if (init)
8518         /* The initialization we're doing here is just a bitwise
8519            copy.  */
8520         assignment = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
8521       else
8522         assignment = NULL_TREE;
8523
8524       /* Once the assignment is complete, set TEMP to 1.  Since the
8525          construction of the static object is complete at this point,
8526          we want to make sure TEMP is set to 1 even if a temporary
8527          constructed during the initialization throws an exception
8528          when it is destroyed.  So, we combine the initialization and
8529          the assignment to TEMP into a single expression, ensuring
8530          that when we call finish_expr_stmt the cleanups will not be
8531          run until after TEMP is set to 1.  */
8532       guard_init = set_guard (guard);
8533       if (assignment)
8534         {
8535           assignment = tree_cons (NULL_TREE, assignment,
8536                                   build_tree_list (NULL_TREE,
8537                                                    guard_init));
8538           assignment = build_compound_expr (assignment);
8539         }
8540       else
8541         assignment = guard_init;
8542       finish_expr_stmt (assignment);
8543
8544       /* Use atexit to register a function for destroying this static
8545          variable.  */
8546       register_dtor_fn (decl);
8547
8548       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8549       finish_then_clause (if_stmt);
8550       finish_if_stmt ();
8551     }
8552   else
8553     static_aggregates = tree_cons (init, decl, static_aggregates);
8554 }
8555
8556 /* Finish the declaration of a catch-parameter.  */
8557
8558 tree
8559 start_handler_parms (declspecs, declarator)
8560      tree declspecs;
8561      tree declarator;
8562 {
8563   tree decl;
8564   if (declspecs)
8565     {
8566       decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8567                              1, NULL_TREE);
8568       if (decl == NULL_TREE)
8569         error ("invalid catch parameter");
8570     }
8571   else
8572     decl = NULL_TREE;
8573
8574   return decl;
8575 }
8576
8577 \f
8578 /* Make TYPE a complete type based on INITIAL_VALUE.
8579    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8580    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
8581
8582 int
8583 complete_array_type (type, initial_value, do_default)
8584      tree type, initial_value;
8585      int do_default;
8586 {
8587   register tree maxindex = NULL_TREE;
8588   int value = 0;
8589
8590   if (initial_value)
8591     {
8592       /* An array of character type can be initialized from a
8593          brace-enclosed string constant.  */
8594       if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))
8595           && TREE_CODE (initial_value) == CONSTRUCTOR
8596           && CONSTRUCTOR_ELTS (initial_value)
8597           && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value)))
8598               == STRING_CST)
8599           && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value)) == NULL_TREE)
8600         initial_value = TREE_VALUE (CONSTRUCTOR_ELTS (initial_value));
8601
8602       /* Note MAXINDEX is really the maximum index, one less than the
8603          size.  */
8604       if (TREE_CODE (initial_value) == STRING_CST)
8605         {
8606           int eltsize
8607             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8608           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8609                                    / eltsize) - 1, 0);
8610         }
8611       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8612         {
8613           tree elts = CONSTRUCTOR_ELTS (initial_value);
8614
8615           maxindex = ssize_int (-1);
8616           for (; elts; elts = TREE_CHAIN (elts))
8617             {
8618               if (TREE_PURPOSE (elts))
8619                 maxindex = TREE_PURPOSE (elts);
8620               else
8621                 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
8622             }
8623           maxindex = copy_node (maxindex);
8624         }
8625       else
8626         {
8627           /* Make an error message unless that happened already.  */
8628           if (initial_value != error_mark_node)
8629             value = 1;
8630           else
8631             initial_value = NULL_TREE;
8632
8633           /* Prevent further error messages.  */
8634           maxindex = build_int_2 (0, 0);
8635         }
8636     }
8637
8638   if (!maxindex)
8639     {
8640       if (do_default)
8641         maxindex = build_int_2 (0, 0);
8642       value = 2;
8643     }
8644
8645   if (maxindex)
8646     {
8647       tree itype;
8648       tree domain;
8649
8650       domain = build_index_type (maxindex);
8651       TYPE_DOMAIN (type) = domain;
8652
8653       if (! TREE_TYPE (maxindex))
8654         TREE_TYPE (maxindex) = domain;
8655       if (initial_value)
8656         itype = TREE_TYPE (initial_value);
8657       else
8658         itype = NULL;
8659       if (itype && !TYPE_DOMAIN (itype))
8660         TYPE_DOMAIN (itype) = domain;
8661       /* The type of the main variant should never be used for arrays
8662          of different sizes.  It should only ever be completed with the
8663          size of the array.  */
8664       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8665         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8666     }
8667
8668   /* Lay out the type now that we can get the real answer.  */
8669
8670   layout_type (type);
8671
8672   return value;
8673 }
8674 \f
8675 /* Return zero if something is declared to be a member of type
8676    CTYPE when in the context of CUR_TYPE.  STRING is the error
8677    message to print in that case.  Otherwise, quietly return 1.  */
8678
8679 static int
8680 member_function_or_else (ctype, cur_type, flags)
8681      tree ctype, cur_type;
8682      enum overload_flags flags;
8683 {
8684   if (ctype && ctype != cur_type)
8685     {
8686       if (flags == DTOR_FLAG)
8687         error ("destructor for alien class `%s' cannot be a member",
8688                TYPE_NAME_STRING (ctype));
8689       else
8690         error ("constructor for alien class `%s' cannot be a member",
8691                TYPE_NAME_STRING (ctype));
8692       return 0;
8693     }
8694   return 1;
8695 }
8696 \f
8697 /* Subroutine of `grokdeclarator'.  */
8698
8699 /* Generate errors possibly applicable for a given set of specifiers.
8700    This is for ARM $7.1.2.  */
8701
8702 static void
8703 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8704      tree object;
8705      const char *type;
8706      int virtualp, quals, friendp, raises, inlinep;
8707 {
8708   if (virtualp)
8709     cp_error ("`%D' declared as a `virtual' %s", object, type);
8710   if (inlinep)
8711     cp_error ("`%D' declared as an `inline' %s", object, type);
8712   if (quals)
8713     cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8714               object, type);
8715   if (friendp)
8716     cp_error_at ("`%D' declared as a friend", object);
8717   if (raises)
8718     cp_error_at ("`%D' declared with an exception specification", object);
8719 }
8720
8721 /* CTYPE is class type, or null if non-class.
8722    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8723    or METHOD_TYPE.
8724    DECLARATOR is the function's name.
8725    VIRTUALP is truthvalue of whether the function is virtual or not.
8726    FLAGS are to be passed through to `grokclassfn'.
8727    QUALS are qualifiers indicating whether the function is `const'
8728    or `volatile'.
8729    RAISES is a list of exceptions that this function can raise.
8730    CHECK is 1 if we must find this method in CTYPE, 0 if we should
8731    not look, and -1 if we should not call `grokclassfn' at all.
8732
8733    Returns `NULL_TREE' if something goes wrong, after issuing
8734    applicable error messages.  */
8735
8736 static tree
8737 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8738             raises, check, friendp, publicp, inlinep, funcdef_flag,
8739             template_count, in_namespace)
8740      tree ctype, type;
8741      tree declarator;
8742      tree orig_declarator;
8743      int virtualp;
8744      enum overload_flags flags;
8745      tree quals, raises;
8746      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8747      tree in_namespace;
8748 {
8749   tree cname, decl;
8750   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8751   int has_default_arg = 0;
8752   tree t;
8753
8754   if (ctype)
8755     cname = TREE_CODE (TYPE_NAME (ctype)) == TYPE_DECL
8756       ? TYPE_IDENTIFIER (ctype) : TYPE_NAME (ctype);
8757   else
8758     cname = NULL_TREE;
8759
8760   if (raises)
8761     {
8762       type = build_exception_variant (type, raises);
8763     }
8764
8765   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8766   /* Propagate volatile out from type to decl. */
8767   if (TYPE_VOLATILE (type))
8768     TREE_THIS_VOLATILE (decl) = 1;
8769
8770   /* If this decl has namespace scope, set that up.  */
8771   if (in_namespace)
8772     set_decl_namespace (decl, in_namespace, friendp);
8773   else if (!ctype)
8774     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8775
8776   /* `main' and builtins have implicit 'C' linkage.  */
8777   if ((MAIN_NAME_P (declarator)
8778        || (IDENTIFIER_LENGTH (declarator) > 10
8779            && IDENTIFIER_POINTER (declarator)[0] == '_'
8780            && IDENTIFIER_POINTER (declarator)[1] == '_'
8781            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8782       && current_lang_name == lang_name_cplusplus
8783       && ctype == NULL_TREE
8784       /* NULL_TREE means global namespace.  */
8785       && DECL_CONTEXT (decl) == NULL_TREE)
8786     DECL_LANGUAGE (decl) = lang_c;
8787
8788   /* Should probably propagate const out from type to decl I bet (mrs).  */
8789   if (staticp)
8790     {
8791       DECL_STATIC_FUNCTION_P (decl) = 1;
8792       DECL_CONTEXT (decl) = ctype;
8793     }
8794
8795   if (ctype)
8796     DECL_CONTEXT (decl) = ctype;
8797
8798   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8799     {
8800       if (processing_template_decl)
8801         error ("cannot declare `::main' to be a template");
8802       if (inlinep)
8803         error ("cannot declare `::main' to be inline");
8804       else if (! publicp)
8805         error ("cannot declare `::main' to be static");
8806       inlinep = 0;
8807       publicp = 1;
8808     }
8809
8810   /* Members of anonymous types and local classes have no linkage; make
8811      them internal.  */
8812   if (ctype && (ANON_AGGRNAME_P (TYPE_IDENTIFIER (ctype))
8813                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
8814     publicp = 0;
8815
8816   if (publicp)
8817     {
8818       /* [basic.link]: A name with no linkage (notably, the name of a class
8819          or enumeration declared in a local scope) shall not be used to
8820          declare an entity with linkage.
8821
8822          Only check this for public decls for now.  */
8823       t = no_linkage_check (TREE_TYPE (decl));
8824       if (t)
8825         {
8826           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8827             {
8828               if (DECL_EXTERN_C_P (decl))
8829                 /* Allow this; it's pretty common in C.  */;
8830               else
8831                 cp_pedwarn ("non-local function `%#D' uses anonymous type",
8832                             decl);
8833             }
8834           else
8835             cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8836                         decl, t);
8837         }
8838     }
8839
8840   TREE_PUBLIC (decl) = publicp;
8841   if (! publicp)
8842     {
8843       DECL_INTERFACE_KNOWN (decl) = 1;
8844       DECL_NOT_REALLY_EXTERN (decl) = 1;
8845     }
8846
8847   if (inlinep)
8848     DECL_THIS_INLINE (decl) = DECL_INLINE (decl) = 1;
8849
8850   DECL_EXTERNAL (decl) = 1;
8851   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
8852     {
8853       cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8854                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
8855       quals = NULL_TREE;
8856     }
8857
8858   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
8859     grok_op_properties (decl, virtualp, check < 0);
8860
8861   if (ctype && decl_function_context (decl))
8862     DECL_NO_STATIC_CHAIN (decl) = 1;
8863
8864   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
8865     if (TREE_PURPOSE (t)
8866         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
8867       {
8868         has_default_arg = 1;
8869         break;
8870       }
8871
8872   if (friendp
8873       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
8874     {
8875       if (funcdef_flag)
8876         cp_error
8877           ("defining explicit specialization `%D' in friend declaration",
8878            orig_declarator);
8879       else
8880         {
8881           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8882             {
8883               /* Something like `template <class T> friend void f<T>()'.  */
8884               cp_error ("invalid use of template-id `%D' in declaration of primary template",
8885                         orig_declarator);
8886               return NULL_TREE;
8887             }
8888
8889
8890           /* A friend declaration of the form friend void f<>().  Record
8891              the information in the TEMPLATE_ID_EXPR.  */
8892           SET_DECL_IMPLICIT_INSTANTIATION (decl);
8893           DECL_TEMPLATE_INFO (decl)
8894             = tree_cons (TREE_OPERAND (orig_declarator, 0),
8895                          TREE_OPERAND (orig_declarator, 1),
8896                          NULL_TREE);
8897
8898           if (has_default_arg)
8899             {
8900               cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8901                         decl);
8902               return NULL_TREE;
8903             }
8904
8905           if (inlinep)
8906             {
8907               cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
8908                         decl);
8909               return NULL_TREE;
8910             }
8911         }
8912     }
8913
8914   if (has_default_arg)
8915     add_defarg_fn (decl);
8916
8917   /* Plain overloading: will not be grok'd by grokclassfn.  */
8918   if (! ctype && ! processing_template_decl
8919       && !DECL_EXTERN_C_P (decl)
8920       && (! DECL_USE_TEMPLATE (decl) || name_mangling_version < 1))
8921     set_mangled_name_for_decl (decl);
8922
8923   if (funcdef_flag)
8924     /* Make the init_value nonzero so pushdecl knows this is not
8925        tentative.  error_mark_node is replaced later with the BLOCK.  */
8926     DECL_INITIAL (decl) = error_mark_node;
8927
8928   if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
8929     TREE_NOTHROW (decl) = 1;
8930
8931   /* Caller will do the rest of this.  */
8932   if (check < 0)
8933     return decl;
8934
8935   if (flags == NO_SPECIAL && ctype && constructor_name (cname) == declarator)
8936     DECL_CONSTRUCTOR_P (decl) = 1;
8937
8938   /* Function gets the ugly name, field gets the nice one.  This call
8939      may change the type of the function (because of default
8940      parameters)!  */
8941   if (ctype != NULL_TREE)
8942     grokclassfn (ctype, decl, flags, quals);
8943
8944   decl = check_explicit_specialization (orig_declarator, decl,
8945                                         template_count,
8946                                         2 * (funcdef_flag != 0) +
8947                                         4 * (friendp != 0));
8948   if (decl == error_mark_node)
8949     return NULL_TREE;
8950
8951   if (ctype != NULL_TREE
8952       && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
8953       && check)
8954     {
8955       tree old_decl;
8956
8957       old_decl = check_classfn (ctype, decl);
8958
8959       if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
8960         /* Because grokfndecl is always supposed to return a
8961            FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
8962            here.  We depend on our callers to figure out that its
8963            really a template that's being returned.  */
8964         old_decl = DECL_TEMPLATE_RESULT (old_decl);
8965
8966       if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
8967           && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
8968         {
8969           /* Remove the `this' parm added by grokclassfn.
8970              XXX Isn't this done in start_function, too?  */
8971           revert_static_member_fn (decl);
8972           last_function_parms = TREE_CHAIN (last_function_parms);
8973         }
8974       if (old_decl && DECL_ARTIFICIAL (old_decl))
8975         cp_error ("definition of implicitly-declared `%D'", old_decl);
8976
8977       if (old_decl)
8978         {
8979           /* Since we've smashed OLD_DECL to its
8980              DECL_TEMPLATE_RESULT, we must do the same to DECL.  */
8981           if (TREE_CODE (decl) == TEMPLATE_DECL)
8982             decl = DECL_TEMPLATE_RESULT (decl);
8983
8984           /* Attempt to merge the declarations.  This can fail, in
8985              the case of some illegal specialization declarations.  */
8986           if (!duplicate_decls (decl, old_decl))
8987             cp_error ("no `%#D' member function declared in class `%T'",
8988                       decl, ctype);
8989           return old_decl;
8990         }
8991     }
8992
8993   if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
8994     return NULL_TREE;
8995
8996   if (ctype == NULL_TREE || check)
8997     return decl;
8998
8999   if (virtualp)
9000     {
9001       DECL_VIRTUAL_P (decl) = 1;
9002       if (DECL_VINDEX (decl) == NULL_TREE)
9003         DECL_VINDEX (decl) = error_mark_node;
9004       IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
9005     }
9006
9007   return decl;
9008 }
9009
9010 static tree
9011 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
9012      tree type;
9013      tree declarator;
9014      RID_BIT_TYPE *specbits_in;
9015      int initialized;
9016      int constp;
9017      tree in_namespace;
9018 {
9019   tree decl;
9020   RID_BIT_TYPE specbits;
9021
9022   specbits = *specbits_in;
9023
9024   if (TREE_CODE (type) == OFFSET_TYPE)
9025     {
9026       /* If you declare a static member so that it
9027          can be initialized, the code will reach here.  */
9028       tree basetype = TYPE_OFFSET_BASETYPE (type);
9029       type = TREE_TYPE (type);
9030       decl = build_lang_decl (VAR_DECL, declarator, type);
9031       DECL_CONTEXT (decl) = basetype;
9032       /* DECL_ASSEMBLER_NAME is needed only for full-instantiated
9033          templates.  */
9034       if (!uses_template_parms (decl))
9035         {
9036           if (flag_new_abi)
9037             DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
9038           else
9039             DECL_ASSEMBLER_NAME (decl) = build_static_name (basetype,
9040                                                             declarator);
9041         }
9042     }
9043   else
9044     {
9045       tree context;
9046
9047       if (in_namespace)
9048         context = in_namespace;
9049       else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
9050         context = current_namespace;
9051       else
9052         context = NULL_TREE;
9053
9054       if (processing_template_decl && context)
9055         /* For global variables, declared in a template, we need the
9056            full lang_decl.  */
9057         decl = build_lang_decl (VAR_DECL, declarator, type);
9058       else
9059         decl = build_decl (VAR_DECL, declarator, type);
9060
9061       if (context)
9062         set_decl_namespace (decl, context, 0);
9063
9064       context = DECL_CONTEXT (decl);
9065       if (declarator && context && current_lang_name != lang_name_c)
9066         {
9067           if (flag_new_abi)
9068             DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
9069           else
9070             DECL_ASSEMBLER_NAME (decl)
9071               = build_static_name (context, declarator);
9072         }
9073     }
9074
9075   if (in_namespace)
9076     set_decl_namespace (decl, in_namespace, 0);
9077
9078   if (RIDBIT_SETP (RID_EXTERN, specbits))
9079     {
9080       DECL_THIS_EXTERN (decl) = 1;
9081       DECL_EXTERNAL (decl) = !initialized;
9082     }
9083
9084   /* In class context, static means one per class,
9085      public access, and static storage.  */
9086   if (DECL_CLASS_SCOPE_P (decl))
9087     {
9088       TREE_PUBLIC (decl) = 1;
9089       TREE_STATIC (decl) = 1;
9090       DECL_EXTERNAL (decl) = 0;
9091     }
9092   /* At top level, either `static' or no s.c. makes a definition
9093      (perhaps tentative), and absence of `static' makes it public.  */
9094   else if (toplevel_bindings_p ())
9095     {
9096       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
9097                             && (DECL_THIS_EXTERN (decl) || ! constp));
9098       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
9099     }
9100   /* Not at top level, only `static' makes a static definition.  */
9101   else
9102     {
9103       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
9104       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
9105     }
9106
9107   if (TREE_PUBLIC (decl))
9108     {
9109       /* [basic.link]: A name with no linkage (notably, the name of a class
9110          or enumeration declared in a local scope) shall not be used to
9111          declare an entity with linkage.
9112
9113          Only check this for public decls for now.  */
9114       tree t = no_linkage_check (TREE_TYPE (decl));
9115       if (t)
9116         {
9117           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
9118             /* Ignore for now; `enum { foo } e' is pretty common.  */;
9119           else
9120             cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
9121                         decl, t);
9122         }
9123     }
9124
9125   return decl;
9126 }
9127
9128 /* Create and return a canonical pointer to member function type, for
9129    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
9130
9131 tree
9132 build_ptrmemfunc_type (type)
9133      tree type;
9134 {
9135   tree fields[4];
9136   tree t;
9137   tree u;
9138   tree unqualified_variant = NULL_TREE;
9139
9140   /* If a canonical type already exists for this type, use it.  We use
9141      this method instead of type_hash_canon, because it only does a
9142      simple equality check on the list of field members.  */
9143
9144   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
9145     return t;
9146
9147   /* Make sure that we always have the unqualified pointer-to-member
9148      type first.  */
9149   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9150     unqualified_variant
9151       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
9152
9153   t = make_aggr_type (RECORD_TYPE);
9154   /* Let the front-end know this is a pointer to member function...  */
9155   TYPE_PTRMEMFUNC_FLAG (t) = 1;
9156   /* ... and not really an aggregate.  */
9157   SET_IS_AGGR_TYPE (t, 0);
9158
9159   if (!flag_new_abi)
9160     {
9161       u = make_aggr_type (UNION_TYPE);
9162       SET_IS_AGGR_TYPE (u, 0);
9163       fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9164       fields[1] = build_decl (FIELD_DECL, delta2_identifier,
9165                               delta_type_node);
9166       finish_builtin_type (u, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9167       TYPE_NAME (u) = NULL_TREE;
9168
9169       fields[0] = build_decl (FIELD_DECL, delta_identifier,
9170                               delta_type_node);
9171       fields[1] = build_decl (FIELD_DECL, index_identifier,
9172                               delta_type_node);
9173       fields[2] = build_decl (FIELD_DECL, pfn_or_delta2_identifier, u);
9174       finish_builtin_type (t, "__ptrmemfunc_type", fields, 2, ptr_type_node);
9175     }
9176   else
9177     {
9178       fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9179       fields[1] = build_decl (FIELD_DECL, delta_identifier,
9180                               delta_type_node);
9181       finish_builtin_type (t, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9182     }
9183
9184   /* Zap out the name so that the back-end will give us the debugging
9185      information for this anonymous RECORD_TYPE.  */
9186   TYPE_NAME (t) = NULL_TREE;
9187
9188   /* If this is not the unqualified form of this pointer-to-member
9189      type, set the TYPE_MAIN_VARIANT for this type to be the
9190      unqualified type.  Since they are actually RECORD_TYPEs that are
9191      not variants of each other, we must do this manually.  */
9192   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9193     {
9194       t = build_qualified_type (t, CP_TYPE_QUALS (type));
9195       TYPE_MAIN_VARIANT (t) = unqualified_variant;
9196       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
9197       TYPE_NEXT_VARIANT (unqualified_variant) = t;
9198     }
9199
9200   /* Cache this pointer-to-member type so that we can find it again
9201      later.  */
9202   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
9203
9204   /* Seems to be wanted.  */
9205   CLASSTYPE_GOT_SEMICOLON (t) = 1;
9206
9207   return t;
9208 }
9209
9210 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9211    Check to see that the definition is valid.  Issue appropriate error
9212    messages.  Return 1 if the definition is particularly bad, or 0
9213    otherwise.  */
9214
9215 int
9216 check_static_variable_definition (decl, type)
9217      tree decl;
9218      tree type;
9219 {
9220   /* Motion 10 at San Diego: If a static const integral data member is
9221      initialized with an integral constant expression, the initializer
9222      may appear either in the declaration (within the class), or in
9223      the definition, but not both.  If it appears in the class, the
9224      member is a member constant.  The file-scope definition is always
9225      required.  */
9226   if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
9227     {
9228       cp_error ("invalid in-class initialization of static data member of non-integral type `%T'",
9229                 type);
9230       /* If we just return the declaration, crashes will sometimes
9231          occur.  We therefore return void_type_node, as if this was a
9232          friend declaration, to cause callers to completely ignore
9233          this declaration.  */
9234       return 1;
9235     }
9236   else if (!CP_TYPE_CONST_P (type))
9237     cp_error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9238               decl);
9239   else if (pedantic && !INTEGRAL_TYPE_P (type))
9240     cp_pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
9241
9242   return 0;
9243 }
9244
9245 /* Given the SIZE (i.e., number of elements) in an array, compute an
9246    appropriate index type for the array.  If non-NULL, NAME is the
9247    name of the thing being declared.  */
9248
9249 tree
9250 compute_array_index_type (name, size)
9251      tree name;
9252      tree size;
9253 {
9254   tree itype;
9255
9256   /* The size might be the result of a cast. */
9257   STRIP_TYPE_NOPS (size);
9258
9259   /* It might be a const variable or enumeration constant.  */
9260   size = decl_constant_value (size);
9261
9262   /* If this involves a template parameter, it will be a constant at
9263      instantiation time, but we don't know what the value is yet.
9264      Even if no template parameters are involved, we may an expression
9265      that is not a constant; we don't even simplify `1 + 2' when
9266      processing a template.  */
9267   if (processing_template_decl)
9268     {
9269       /* Resolve a qualified reference to an enumerator or static
9270          const data member of ours.  */
9271       if (TREE_CODE (size) == SCOPE_REF
9272           && TREE_OPERAND (size, 0) == current_class_type)
9273         {
9274           tree t = lookup_field (current_class_type,
9275                                  TREE_OPERAND (size, 1), 0, 0);
9276           if (t)
9277             size = t;
9278         }
9279
9280       return build_index_type (build_min (MINUS_EXPR, sizetype,
9281                                           size, integer_one_node));
9282     }
9283
9284   /* The array bound must be an integer type.  */
9285   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9286       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
9287       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
9288     {
9289       if (name)
9290         cp_error ("size of array `%D' has non-integer type", name);
9291       else
9292         cp_error ("size of array has non-integer type");
9293       size = integer_one_node;
9294     }
9295
9296   /* Normally, the array-bound will be a constant.  */
9297   if (TREE_CODE (size) == INTEGER_CST)
9298     {
9299       /* Check to see if the array bound overflowed.  Make that an
9300          error, no matter how generous we're being.  */
9301       int old_flag_pedantic_errors = flag_pedantic_errors;
9302       int old_pedantic = pedantic;
9303       pedantic = flag_pedantic_errors = 1;
9304       constant_expression_warning (size);
9305       pedantic = old_pedantic;
9306       flag_pedantic_errors = old_flag_pedantic_errors;
9307
9308       /* An array must have a positive number of elements.  */
9309       if (INT_CST_LT (size, integer_zero_node))
9310         {
9311           if (name)
9312             cp_error ("size of array `%D' is negative", name);
9313           else
9314             cp_error ("size of array is negative");
9315           size = integer_one_node;
9316         }
9317       /* Except that an extension we allow zero-sized arrays.  We
9318          always allow them in system headers because glibc uses
9319          them.  */
9320       else if (integer_zerop (size) && pedantic && !in_system_header)
9321         {
9322           if (name)
9323             cp_pedwarn ("ISO C++ forbids zero-size array `%D'", name);
9324           else
9325             cp_pedwarn ("ISO C++ forbids zero-size array");
9326         }
9327     }
9328   else if (TREE_CONSTANT (size))
9329     {
9330       /* `(int) &fn' is not a valid array bound.  */
9331       if (name)
9332         cp_error ("size of array `%D' is not an integral constant-expression",
9333                   name);
9334       else
9335         cp_error ("size of array is not an integral constant-expression");
9336     }
9337
9338   /* Compute the index of the largest element in the array.  It is
9339      one less than the number of elements in the array.  */
9340   itype
9341     = fold (cp_build_binary_op (MINUS_EXPR,
9342                                 cp_convert (ssizetype, size),
9343                                 cp_convert (ssizetype,
9344                                             integer_one_node)));
9345
9346   /* Check for variable-sized arrays.  We allow such things as an
9347      extension, even though they are not allowed in ANSI/ISO C++.  */
9348   if (!TREE_CONSTANT (itype))
9349     {
9350       if (pedantic)
9351         {
9352           if (name)
9353             cp_pedwarn ("ISO C++ forbids variable-size array `%D'",
9354                         name);
9355           else
9356             cp_pedwarn ("ISO C++ forbids variable-size array");
9357         }
9358
9359       /* Create a variable-sized array index type.  */
9360       itype = variable_size (itype);
9361     }
9362   /* Make sure that there was no overflow when creating to a signed
9363      index type.  (For example, on a 32-bit machine, an array with
9364      size 2^32 - 1 is too big.)  */
9365   else if (TREE_OVERFLOW (itype))
9366     {
9367       error ("overflow in array dimension");
9368       TREE_OVERFLOW (itype) = 0;
9369     }
9370
9371   /* Create and return the appropriate index type.  */
9372   return build_index_type (itype);
9373 }
9374
9375 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9376    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
9377    with this type.  */
9378
9379 static tree
9380 create_array_type_for_decl (name, type, size)
9381      tree name;
9382      tree type;
9383      tree size;
9384 {
9385   tree itype = NULL_TREE;
9386   const char* error_msg;
9387
9388   /* If things have already gone awry, bail now.  */
9389   if (type == error_mark_node || size == error_mark_node)
9390     return error_mark_node;
9391
9392   /* Assume that everything will go OK.  */
9393   error_msg = NULL;
9394
9395   /* There are some types which cannot be array elements.  */
9396   switch (TREE_CODE (type))
9397     {
9398     case VOID_TYPE:
9399       error_msg = "array of void";
9400       break;
9401
9402     case FUNCTION_TYPE:
9403       error_msg = "array of functions";
9404       break;
9405
9406     case REFERENCE_TYPE:
9407       error_msg = "array of references";
9408       break;
9409
9410     case OFFSET_TYPE:
9411       error_msg = "array of data members";
9412       break;
9413
9414     case METHOD_TYPE:
9415       error_msg = "array of function members";
9416       break;
9417
9418     default:
9419       break;
9420     }
9421
9422   /* If something went wrong, issue an error-message and return.  */
9423   if (error_msg)
9424     {
9425       if (name)
9426         cp_error ("declaration of `%D' as %s", name, error_msg);
9427       else
9428         cp_error ("creating %s", error_msg);
9429
9430       return error_mark_node;
9431     }
9432
9433   /* [dcl.array]
9434
9435      The constant expressions that specify the bounds of the arrays
9436      can be omitted only for the first member of the sequence.  */
9437   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9438     {
9439       cp_error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9440                 name);
9441
9442       return error_mark_node;
9443     }
9444
9445   /* Figure out the index type for the array.  */
9446   if (size)
9447     itype = compute_array_index_type (name, size);
9448
9449   return build_cplus_array_type (type, itype);
9450 }
9451
9452 /* Check that it's OK to declare a function with the indicated TYPE.
9453    SFK indicates the kind of special function (if any) that this
9454    function is.  CTYPE is the class of which this function is a
9455    member.  OPTYPE is the type given in a conversion operator
9456    declaration.  Returns the actual return type of the function; that
9457    may be different than TYPE if an error occurs, or for certain
9458    special functions.  */
9459
9460 static tree
9461 check_special_function_return_type (sfk, type, ctype, optype)
9462      special_function_kind sfk;
9463      tree type;
9464      tree ctype;
9465      tree optype;
9466 {
9467   switch (sfk)
9468     {
9469     case sfk_constructor:
9470       if (type)
9471         cp_error ("return type specification for constructor invalid");
9472
9473       /* In the old ABI, we return `this'; in the new ABI we don't
9474          bother.  */
9475       type = flag_new_abi ? void_type_node : build_pointer_type (ctype);
9476       break;
9477
9478     case sfk_destructor:
9479       if (type)
9480         cp_error ("return type specification for destructor invalid");
9481       type = void_type_node;
9482       break;
9483
9484     case sfk_conversion:
9485       if (type && !same_type_p (type, optype))
9486         cp_error ("operator `%T' declared to return `%T'", optype, type);
9487       else if (type)
9488         cp_pedwarn ("return type specified for `operator %T'",  optype);
9489       type = optype;
9490       break;
9491
9492     default:
9493       my_friendly_abort (20000408);
9494       break;
9495     }
9496
9497   return type;
9498 }
9499
9500 /* Given declspecs and a declarator,
9501    determine the name and type of the object declared
9502    and construct a ..._DECL node for it.
9503    (In one case we can return a ..._TYPE node instead.
9504     For invalid input we sometimes return 0.)
9505
9506    DECLSPECS is a chain of tree_list nodes whose value fields
9507     are the storage classes and type specifiers.
9508
9509    DECL_CONTEXT says which syntactic context this declaration is in:
9510      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9511      FUNCDEF for a function definition.  Like NORMAL but a few different
9512       error messages in each case.  Return value may be zero meaning
9513       this definition is too screwy to try to parse.
9514      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
9515       handle member functions (which have FIELD context).
9516       Return value may be zero meaning this definition is too screwy to
9517       try to parse.
9518      PARM for a parameter declaration (either within a function prototype
9519       or before a function body).  Make a PARM_DECL, or return void_type_node.
9520      CATCHPARM for a parameter declaration before a catch clause.
9521      TYPENAME if for a typename (in a cast or sizeof).
9522       Don't make a DECL node; just return the ..._TYPE node.
9523      FIELD for a struct or union field; make a FIELD_DECL.
9524      BITFIELD for a field with specified width.
9525    INITIALIZED is 1 if the decl has an initializer.
9526
9527    ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
9528    normal attributes in TREE_PURPOSE, or NULL_TREE.
9529
9530    In the TYPENAME case, DECLARATOR is really an abstract declarator.
9531    It may also be so in the PARM case, for a prototype where the
9532    argument type is specified but not the name.
9533
9534    This function is where the complicated C meanings of `static'
9535    and `extern' are interpreted.
9536
9537    For C++, if there is any monkey business to do, the function which
9538    calls this one must do it, i.e., prepending instance variables,
9539    renaming overloaded function names, etc.
9540
9541    Note that for this C++, it is an error to define a method within a class
9542    which does not belong to that class.
9543
9544    Except in the case where SCOPE_REFs are implicitly known (such as
9545    methods within a class being redundantly qualified),
9546    declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9547    (class_name::decl_name).  The caller must also deal with this.
9548
9549    If a constructor or destructor is seen, and the context is FIELD,
9550    then the type gains the attribute TREE_HAS_x.  If such a declaration
9551    is erroneous, NULL_TREE is returned.
9552
9553    QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
9554    function, these are the qualifiers to give to the `this' pointer. We
9555    apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9556
9557    May return void_type_node if the declarator turned out to be a friend.
9558    See grokfield for details.  */
9559
9560 tree
9561 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9562      tree declspecs;
9563      tree declarator;
9564      enum decl_context decl_context;
9565      int initialized;
9566      tree attrlist;
9567 {
9568   RID_BIT_TYPE specbits;
9569   int nclasses = 0;
9570   tree spec;
9571   tree type = NULL_TREE;
9572   int longlong = 0;
9573   int constp;
9574   int restrictp;
9575   int volatilep;
9576   int type_quals;
9577   int virtualp, explicitp, friendp, inlinep, staticp;
9578   int explicit_int = 0;
9579   int explicit_char = 0;
9580   int defaulted_int = 0;
9581   tree typedef_decl = NULL_TREE;
9582   const char *name;
9583   tree typedef_type = NULL_TREE;
9584   int funcdef_flag = 0;
9585   enum tree_code innermost_code = ERROR_MARK;
9586   int bitfield = 0;
9587 #if 0
9588   /* See the code below that used this.  */
9589   tree decl_machine_attr = NULL_TREE;
9590 #endif
9591   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9592      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9593   tree init = NULL_TREE;
9594
9595   /* Keep track of what sort of function is being processed
9596      so that we can warn about default return values, or explicit
9597      return values which do not match prescribed defaults.  */
9598   special_function_kind sfk = sfk_none;
9599
9600   tree dname = NULL_TREE;
9601   tree ctype = current_class_type;
9602   tree ctor_return_type = NULL_TREE;
9603   enum overload_flags flags = NO_SPECIAL;
9604   tree quals = NULL_TREE;
9605   tree raises = NULL_TREE;
9606   int template_count = 0;
9607   tree in_namespace = NULL_TREE;
9608   tree inner_attrs;
9609   int ignore_attrs;
9610
9611   RIDBIT_RESET_ALL (specbits);
9612   if (decl_context == FUNCDEF)
9613     funcdef_flag = 1, decl_context = NORMAL;
9614   else if (decl_context == MEMFUNCDEF)
9615     funcdef_flag = -1, decl_context = FIELD;
9616   else if (decl_context == BITFIELD)
9617     bitfield = 1, decl_context = FIELD;
9618
9619   /* Look inside a declarator for the name being declared
9620      and get it as a string, for an error message.  */
9621   {
9622     tree *next = &declarator;
9623     register tree decl;
9624     name = NULL;
9625
9626     while (next && *next)
9627       {
9628         decl = *next;
9629         switch (TREE_CODE (decl))
9630           {
9631           case TREE_LIST:
9632             /* For attributes.  */
9633             next = &TREE_VALUE (decl);
9634             break;
9635
9636           case COND_EXPR:
9637             ctype = NULL_TREE;
9638             next = &TREE_OPERAND (decl, 0);
9639             break;
9640
9641           case BIT_NOT_EXPR:    /* For C++ destructors!  */
9642             {
9643               tree name = TREE_OPERAND (decl, 0);
9644               tree rename = NULL_TREE;
9645
9646               my_friendly_assert (flags == NO_SPECIAL, 152);
9647               flags = DTOR_FLAG;
9648               sfk = sfk_destructor;
9649               if (TREE_CODE (name) == TYPE_DECL)
9650                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9651               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9652               if (ctype == NULL_TREE)
9653                 {
9654                   if (current_class_type == NULL_TREE)
9655                     {
9656                       error ("destructors must be member functions");
9657                       flags = NO_SPECIAL;
9658                     }
9659                   else
9660                     {
9661                       tree t = constructor_name (current_class_name);
9662                       if (t != name)
9663                         rename = t;
9664                     }
9665                 }
9666               else
9667                 {
9668                   tree t = constructor_name (ctype);
9669                   if (t != name)
9670                     rename = t;
9671                 }
9672
9673               if (rename)
9674                 {
9675                   cp_error ("destructor `%T' must match class name `%T'",
9676                             name, rename);
9677                   TREE_OPERAND (decl, 0) = rename;
9678                 }
9679               next = &name;
9680             }
9681             break;
9682
9683           case ADDR_EXPR:       /* C++ reference declaration */
9684             /* Fall through. */
9685           case ARRAY_REF:
9686           case INDIRECT_REF:
9687             ctype = NULL_TREE;
9688             innermost_code = TREE_CODE (decl);
9689             next = &TREE_OPERAND (decl, 0);
9690             break;
9691
9692           case CALL_EXPR:
9693             if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
9694               {
9695                 /* This is actually a variable declaration using
9696                    constructor syntax.  We need to call start_decl and
9697                    cp_finish_decl so we can get the variable
9698                    initialized...  */
9699
9700                 tree attributes, prefix_attributes;
9701
9702                 *next = TREE_OPERAND (decl, 0);
9703                 init = CALL_DECLARATOR_PARMS (decl);
9704
9705                 if (attrlist)
9706                   {
9707                     attributes = TREE_PURPOSE (attrlist);
9708                     prefix_attributes = TREE_VALUE (attrlist);
9709                   }
9710                 else
9711                   {
9712                     attributes = NULL_TREE;
9713                     prefix_attributes = NULL_TREE;
9714                   }
9715
9716                 decl = start_decl (declarator, declspecs, 1,
9717                                    attributes, prefix_attributes);
9718                 decl_type_access_control (decl);
9719                 if (decl)
9720                   {
9721                     /* Look for __unused__ attribute */
9722                     if (TREE_USED (TREE_TYPE (decl)))
9723                       TREE_USED (decl) = 1;
9724                     finish_decl (decl, init, NULL_TREE);
9725                   }
9726                 else
9727                   cp_error ("invalid declarator");
9728                 return 0;
9729               }
9730             innermost_code = TREE_CODE (decl);
9731             if (decl_context == FIELD && ctype == NULL_TREE)
9732               ctype = current_class_type;
9733             if (ctype
9734                 && TREE_OPERAND (decl, 0)
9735                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9736                     && ((DECL_NAME (TREE_OPERAND (decl, 0))
9737                          == constructor_name_full (ctype))
9738                         || (DECL_NAME (TREE_OPERAND (decl, 0))
9739                             == constructor_name (ctype)))))
9740               TREE_OPERAND (decl, 0) = constructor_name (ctype);
9741             next = &TREE_OPERAND (decl, 0);
9742             decl = *next;
9743             if (ctype != NULL_TREE
9744                 && decl != NULL_TREE && flags != DTOR_FLAG
9745                 && decl == constructor_name (ctype))
9746               {
9747                 sfk = sfk_constructor;
9748                 ctor_return_type = ctype;
9749               }
9750             ctype = NULL_TREE;
9751             break;
9752
9753           case TEMPLATE_ID_EXPR:
9754               {
9755                 tree fns = TREE_OPERAND (decl, 0);
9756
9757                 if (TREE_CODE (fns) == LOOKUP_EXPR)
9758                   fns = TREE_OPERAND (fns, 0);
9759
9760                 dname = fns;
9761                 if (TREE_CODE (dname) == COMPONENT_REF)
9762                   dname = TREE_OPERAND (dname, 1);
9763                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9764                   {
9765                     my_friendly_assert (is_overloaded_fn (dname),
9766                                         19990331);
9767                     dname = DECL_NAME (get_first_fn (dname));
9768                   }
9769               }
9770           /* Fall through. */
9771
9772           case IDENTIFIER_NODE:
9773             if (TREE_CODE (decl) == IDENTIFIER_NODE)
9774               dname = decl;
9775
9776             next = 0;
9777
9778             if (is_rid (dname))
9779               {
9780                 cp_error ("declarator-id missing; using reserved word `%D'",
9781                           dname);
9782                 name = IDENTIFIER_POINTER (dname);
9783               }
9784             else if (!IDENTIFIER_TYPENAME_P (dname))
9785               name = IDENTIFIER_POINTER (dname);
9786             else
9787               {
9788                 my_friendly_assert (flags == NO_SPECIAL, 154);
9789                 flags = TYPENAME_FLAG;
9790                 ctor_return_type = TREE_TYPE (dname);
9791                 sfk = sfk_conversion;
9792                 if (IDENTIFIER_GLOBAL_VALUE (dname)
9793                     && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (dname))
9794                         == TYPE_DECL))
9795                   name = IDENTIFIER_POINTER (dname);
9796                 else
9797                   name = "<invalid operator>";
9798               }
9799             break;
9800
9801             /* C++ extension */
9802           case SCOPE_REF:
9803             {
9804               /* Perform error checking, and decide on a ctype.  */
9805               tree cname = TREE_OPERAND (decl, 0);
9806               if (cname == NULL_TREE)
9807                 ctype = NULL_TREE;
9808               else if (TREE_CODE (cname) == NAMESPACE_DECL)
9809                 {
9810                   ctype = NULL_TREE;
9811                   in_namespace = TREE_OPERAND (decl, 0);
9812                   TREE_OPERAND (decl, 0) = NULL_TREE;
9813                 }
9814               else if (! is_aggr_type (cname, 1))
9815                 TREE_OPERAND (decl, 0) = NULL_TREE;
9816               /* Must test TREE_OPERAND (decl, 1), in case user gives
9817                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
9818               else if (TREE_OPERAND (decl, 1)
9819                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9820                 ctype = cname;
9821               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9822                        || TREE_CODE (cname) == TEMPLATE_TEMPLATE_PARM)
9823                 {
9824                   cp_error ("`%T::%D' is not a valid declarator", cname,
9825                             TREE_OPERAND (decl, 1));
9826                   cp_error ("  perhaps you want `typename %T::%D' to make it a type",
9827                             cname, TREE_OPERAND (decl, 1));
9828                   return void_type_node;
9829                 }
9830               else if (ctype == NULL_TREE)
9831                 ctype = cname;
9832               else if (TREE_COMPLEXITY (decl) == current_class_depth)
9833                 TREE_OPERAND (decl, 0) = ctype;
9834               else
9835                 {
9836                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9837                     {
9838                       cp_error ("type `%T' is not derived from type `%T'",
9839                                 cname, ctype);
9840                       TREE_OPERAND (decl, 0) = NULL_TREE;
9841                     }
9842                   else
9843                     ctype = cname;
9844                 }
9845
9846               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
9847                   && ((DECL_NAME (TREE_OPERAND (decl, 1))
9848                        == constructor_name_full (ctype))
9849                       || (DECL_NAME (TREE_OPERAND (decl, 1))
9850                           == constructor_name (ctype))))
9851                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
9852               next = &TREE_OPERAND (decl, 1);
9853               decl = *next;
9854               if (ctype)
9855                 {
9856                   if (TREE_CODE (decl) == IDENTIFIER_NODE
9857                       && constructor_name (ctype) == decl)
9858                     {
9859                       sfk = sfk_constructor;
9860                       ctor_return_type = ctype;
9861                     }
9862                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
9863                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
9864                            && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
9865                                || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
9866                     {
9867                       sfk = sfk_destructor;
9868                       ctor_return_type = ctype;
9869                       flags = DTOR_FLAG;
9870                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
9871                       next = &TREE_OPERAND (decl, 0);
9872                     }
9873                 }
9874             }
9875             break;
9876
9877           case ERROR_MARK:
9878             next = 0;
9879             break;
9880
9881           case TYPE_DECL:
9882             /* Parse error puts this typespec where
9883                a declarator should go.  */
9884             cp_error ("`%T' specified as declarator-id", DECL_NAME (decl));
9885             if (TREE_TYPE (decl) == current_class_type)
9886               cp_error ("  perhaps you want `%T' for a constructor",
9887                         current_class_name);
9888             dname = DECL_NAME (decl);
9889             name = IDENTIFIER_POINTER (dname);
9890
9891             /* Avoid giving two errors for this.  */
9892             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
9893
9894             declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
9895             *next = dname;
9896             next = 0;
9897             break;
9898
9899           default:
9900             cp_compiler_error ("`%D' as declarator", decl);
9901             return 0; /* We used to do a 155 abort here.  */
9902           }
9903       }
9904   }
9905
9906   /* A function definition's declarator must have the form of
9907      a function declarator.  */
9908
9909   if (funcdef_flag && innermost_code != CALL_EXPR)
9910     return 0;
9911
9912   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
9913       && innermost_code != CALL_EXPR
9914       && ! (ctype && declspecs == NULL_TREE))
9915     {
9916       cp_error ("declaration of `%D' as non-function", dname);
9917       return void_type_node;
9918     }
9919
9920   /* Anything declared one level down from the top level
9921      must be one of the parameters of a function
9922      (because the body is at least two levels down).  */
9923
9924   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9925      by not allowing C++ class definitions to specify their parameters
9926      with xdecls (must be spec.d in the parmlist).
9927
9928      Since we now wait to push a class scope until we are sure that
9929      we are in a legitimate method context, we must set oldcname
9930      explicitly (since current_class_name is not yet alive).
9931
9932      We also want to avoid calling this a PARM if it is in a namespace.  */
9933
9934   if (decl_context == NORMAL && !toplevel_bindings_p ())
9935     {
9936       struct binding_level *b = current_binding_level;
9937       current_binding_level = b->level_chain;
9938       if (current_binding_level != 0 && toplevel_bindings_p ())
9939         decl_context = PARM;
9940       current_binding_level = b;
9941     }
9942
9943   if (name == NULL)
9944     name = decl_context == PARM ? "parameter" : "type name";
9945
9946   /* Look through the decl specs and record which ones appear.
9947      Some typespecs are defined as built-in typenames.
9948      Others, the ones that are modifiers of other types,
9949      are represented by bits in SPECBITS: set the bits for
9950      the modifiers that appear.  Storage class keywords are also in SPECBITS.
9951
9952      If there is a typedef name or a type, store the type in TYPE.
9953      This includes builtin typedefs such as `int'.
9954
9955      Set EXPLICIT_INT if the type is `int' or `char' and did not
9956      come from a user typedef.
9957
9958      Set LONGLONG if `long' is mentioned twice.
9959
9960      For C++, constructors and destructors have their own fast treatment.  */
9961
9962   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
9963     {
9964       register int i;
9965       register tree id;
9966
9967       /* Certain parse errors slip through.  For example,
9968          `int class;' is not caught by the parser. Try
9969          weakly to recover here.  */
9970       if (TREE_CODE (spec) != TREE_LIST)
9971         return 0;
9972
9973       id = TREE_VALUE (spec);
9974
9975       if (TREE_CODE (id) == IDENTIFIER_NODE)
9976         {
9977           if (id == ridpointers[(int) RID_INT]
9978               || id == ridpointers[(int) RID_CHAR]
9979               || id == ridpointers[(int) RID_BOOL]
9980               || id == ridpointers[(int) RID_WCHAR])
9981             {
9982               if (type)
9983                 {
9984                   if (id == ridpointers[(int) RID_BOOL])
9985                     error ("`bool' is now a keyword");
9986                   else
9987                     cp_error ("extraneous `%T' ignored", id);
9988                 }
9989               else
9990                 {
9991                   if (id == ridpointers[(int) RID_INT])
9992                     explicit_int = 1;
9993                   else if (id == ridpointers[(int) RID_CHAR])
9994                     explicit_char = 1;
9995                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
9996                 }
9997               goto found;
9998             }
9999           /* C++ aggregate types.  */
10000           if (IDENTIFIER_HAS_TYPE_VALUE (id))
10001             {
10002               if (type)
10003                 cp_error ("multiple declarations `%T' and `%T'", type, id);
10004               else
10005                 type = IDENTIFIER_TYPE_VALUE (id);
10006               goto found;
10007             }
10008
10009           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
10010             {
10011               if (ridpointers[i] == id)
10012                 {
10013                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
10014                     {
10015                       if (pedantic && ! in_system_header && warn_long_long)
10016                         pedwarn ("ISO C++ does not support `long long'");
10017                       if (longlong)
10018                         error ("`long long long' is too long for GCC");
10019                       else
10020                         longlong = 1;
10021                     }
10022                   else if (RIDBIT_SETP (i, specbits))
10023                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
10024                   RIDBIT_SET (i, specbits);
10025                   goto found;
10026                 }
10027             }
10028         }
10029       /* C++ aggregate types.  */
10030       else if (TREE_CODE (id) == TYPE_DECL)
10031         {
10032           if (type)
10033             cp_error ("multiple declarations `%T' and `%T'", type,
10034                       TREE_TYPE (id));
10035           else
10036             {
10037               type = TREE_TYPE (id);
10038               TREE_VALUE (spec) = type;
10039             }
10040           goto found;
10041         }
10042       if (type)
10043         error ("two or more data types in declaration of `%s'", name);
10044       else if (TREE_CODE (id) == IDENTIFIER_NODE)
10045         {
10046           register tree t = lookup_name (id, 1);
10047           if (!t || TREE_CODE (t) != TYPE_DECL)
10048             error ("`%s' fails to be a typedef or built in type",
10049                    IDENTIFIER_POINTER (id));
10050           else
10051             {
10052               type = TREE_TYPE (t);
10053 #if 0
10054               /* See the code below that used this.  */
10055               decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
10056 #endif
10057               typedef_decl = t;
10058             }
10059         }
10060       else if (id != error_mark_node)
10061         /* Can't change CLASS nodes into RECORD nodes here!  */
10062         type = id;
10063
10064     found: ;
10065     }
10066
10067   typedef_type = type;
10068
10069   /* No type at all: default to `int', and set DEFAULTED_INT
10070      because it was not a user-defined typedef.  */
10071
10072   if (type == NULL_TREE
10073       && (RIDBIT_SETP (RID_SIGNED, specbits)
10074           || RIDBIT_SETP (RID_UNSIGNED, specbits)
10075           || RIDBIT_SETP (RID_LONG, specbits)
10076           || RIDBIT_SETP (RID_SHORT, specbits)))
10077     {
10078       /* These imply 'int'.  */
10079       type = integer_type_node;
10080       defaulted_int = 1;
10081     }
10082
10083   if (sfk != sfk_none)
10084     type = check_special_function_return_type (sfk, type,
10085                                                ctor_return_type,
10086                                                ctor_return_type);
10087   else if (type == NULL_TREE)
10088     {
10089       int is_main;
10090
10091       explicit_int = -1;
10092
10093           /* We handle `main' specially here, because 'main () { }' is so
10094              common.  With no options, it is allowed.  With -Wreturn-type,
10095              it is a warning.  It is only an error with -pedantic-errors.  */
10096       is_main = (funcdef_flag
10097                  && MAIN_NAME_P (dname)
10098                  && ctype == NULL_TREE
10099                  && in_namespace == NULL_TREE
10100                  && current_namespace == global_namespace);
10101
10102       if (in_system_header || flag_ms_extensions)
10103         /* Allow it, sigh.  */;
10104       else if (pedantic || ! is_main)
10105         cp_pedwarn ("ISO C++ forbids declaration of `%s' with no type",
10106                     name);
10107       else if (warn_return_type)
10108         cp_warning ("ISO C++ forbids declaration of `%s' with no type",
10109                     name);
10110
10111       type = integer_type_node;
10112     }
10113
10114   ctype = NULL_TREE;
10115
10116   /* Now process the modifiers that were specified
10117      and check for invalid combinations.  */
10118
10119   /* Long double is a special combination.  */
10120
10121   if (RIDBIT_SETP (RID_LONG, specbits)
10122       && TYPE_MAIN_VARIANT (type) == double_type_node)
10123     {
10124       RIDBIT_RESET (RID_LONG, specbits);
10125       type = build_qualified_type (long_double_type_node,
10126                                    CP_TYPE_QUALS (type));
10127     }
10128
10129   /* Check all other uses of type modifiers.  */
10130
10131   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10132       || RIDBIT_SETP (RID_SIGNED, specbits)
10133       || RIDBIT_SETP (RID_LONG, specbits)
10134       || RIDBIT_SETP (RID_SHORT, specbits))
10135     {
10136       int ok = 0;
10137
10138       if (TREE_CODE (type) == REAL_TYPE)
10139         error ("short, signed or unsigned invalid for `%s'", name);
10140       else if (TREE_CODE (type) != INTEGER_TYPE)
10141         error ("long, short, signed or unsigned invalid for `%s'", name);
10142       else if (RIDBIT_SETP (RID_LONG, specbits)
10143                && RIDBIT_SETP (RID_SHORT, specbits))
10144         error ("long and short specified together for `%s'", name);
10145       else if ((RIDBIT_SETP (RID_LONG, specbits)
10146                 || RIDBIT_SETP (RID_SHORT, specbits))
10147                && explicit_char)
10148         error ("long or short specified with char for `%s'", name);
10149       else if ((RIDBIT_SETP (RID_LONG, specbits)
10150                 || RIDBIT_SETP (RID_SHORT, specbits))
10151                && TREE_CODE (type) == REAL_TYPE)
10152         error ("long or short specified with floating type for `%s'", name);
10153       else if (RIDBIT_SETP (RID_SIGNED, specbits)
10154                && RIDBIT_SETP (RID_UNSIGNED, specbits))
10155         error ("signed and unsigned given together for `%s'", name);
10156       else
10157         {
10158           ok = 1;
10159           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
10160             {
10161               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10162                        name);
10163               if (flag_pedantic_errors)
10164                 ok = 0;
10165             }
10166         }
10167
10168       /* Discard the type modifiers if they are invalid.  */
10169       if (! ok)
10170         {
10171           RIDBIT_RESET (RID_UNSIGNED, specbits);
10172           RIDBIT_RESET (RID_SIGNED, specbits);
10173           RIDBIT_RESET (RID_LONG, specbits);
10174           RIDBIT_RESET (RID_SHORT, specbits);
10175           longlong = 0;
10176         }
10177     }
10178
10179   if (RIDBIT_SETP (RID_COMPLEX, specbits)
10180       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
10181     {
10182       error ("complex invalid for `%s'", name);
10183       RIDBIT_RESET (RID_COMPLEX, specbits);
10184     }
10185
10186   /* Decide whether an integer type is signed or not.
10187      Optionally treat bitfields as signed by default.  */
10188   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10189       /* [class.bit]
10190
10191          It is implementation-defined whether a plain (neither
10192          explicitly signed or unsigned) char, short, int, or long
10193          bit-field is signed or unsigned.
10194
10195          Naturally, we extend this to long long as well.  Note that
10196          this does not include wchar_t.  */
10197       || (bitfield && !flag_signed_bitfields
10198           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
10199           /* A typedef for plain `int' without `signed' can be
10200              controlled just like plain `int', but a typedef for
10201              `signed int' cannot be so controlled.  */
10202           && !(typedef_decl
10203                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
10204           && (TREE_CODE (type) == INTEGER_TYPE
10205               || TREE_CODE (type) == CHAR_TYPE)
10206           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
10207     {
10208       if (longlong)
10209         type = long_long_unsigned_type_node;
10210       else if (RIDBIT_SETP (RID_LONG, specbits))
10211         type = long_unsigned_type_node;
10212       else if (RIDBIT_SETP (RID_SHORT, specbits))
10213         type = short_unsigned_type_node;
10214       else if (type == char_type_node)
10215         type = unsigned_char_type_node;
10216       else if (typedef_decl)
10217         type = unsigned_type (type);
10218       else
10219         type = unsigned_type_node;
10220     }
10221   else if (RIDBIT_SETP (RID_SIGNED, specbits)
10222            && type == char_type_node)
10223     type = signed_char_type_node;
10224   else if (longlong)
10225     type = long_long_integer_type_node;
10226   else if (RIDBIT_SETP (RID_LONG, specbits))
10227     type = long_integer_type_node;
10228   else if (RIDBIT_SETP (RID_SHORT, specbits))
10229     type = short_integer_type_node;
10230
10231   if (RIDBIT_SETP (RID_COMPLEX, specbits))
10232     {
10233       /* If we just have "complex", it is equivalent to
10234          "complex double", but if any modifiers at all are specified it is
10235          the complex form of TYPE.  E.g, "complex short" is
10236          "complex short int".  */
10237
10238       if (defaulted_int && ! longlong
10239           && ! (RIDBIT_SETP (RID_LONG, specbits)
10240                 || RIDBIT_SETP (RID_SHORT, specbits)
10241                 || RIDBIT_SETP (RID_SIGNED, specbits)
10242                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
10243         type = complex_double_type_node;
10244       else if (type == integer_type_node)
10245         type = complex_integer_type_node;
10246       else if (type == float_type_node)
10247         type = complex_float_type_node;
10248       else if (type == double_type_node)
10249         type = complex_double_type_node;
10250       else if (type == long_double_type_node)
10251         type = complex_long_double_type_node;
10252       else
10253         type = build_complex_type (type);
10254     }
10255
10256   if (sfk == sfk_conversion
10257       && (RIDBIT_SETP (RID_CONST, specbits)
10258           || RIDBIT_SETP (RID_VOLATILE, specbits)
10259           || RIDBIT_SETP (RID_RESTRICT, specbits)))
10260     cp_error ("qualifiers are not allowed on declaration of `operator %T'",
10261               ctor_return_type);
10262
10263   /* Set CONSTP if this declaration is `const', whether by
10264      explicit specification or via a typedef.
10265      Likewise for VOLATILEP.  */
10266
10267   constp = !! RIDBIT_SETP (RID_CONST, specbits) + CP_TYPE_CONST_P (type);
10268   restrictp =
10269     !! RIDBIT_SETP (RID_RESTRICT, specbits) + CP_TYPE_RESTRICT_P (type);
10270   volatilep =
10271     !! RIDBIT_SETP (RID_VOLATILE, specbits) + CP_TYPE_VOLATILE_P (type);
10272   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10273                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10274                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10275   type = cp_build_qualified_type (type, type_quals);
10276   staticp = 0;
10277   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
10278   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
10279   RIDBIT_RESET (RID_VIRTUAL, specbits);
10280   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
10281   RIDBIT_RESET (RID_EXPLICIT, specbits);
10282
10283   if (RIDBIT_SETP (RID_STATIC, specbits))
10284     staticp = 1 + (decl_context == FIELD);
10285
10286   if (virtualp && staticp == 2)
10287     {
10288       cp_error ("member `%D' cannot be declared both virtual and static",
10289                 dname);
10290       staticp = 0;
10291     }
10292   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
10293   RIDBIT_RESET (RID_FRIEND, specbits);
10294
10295   /* Warn if two storage classes are given. Default to `auto'.  */
10296
10297   if (RIDBIT_ANY_SET (specbits))
10298     {
10299       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
10300       if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
10301       if (decl_context == PARM && nclasses > 0)
10302         error ("storage class specifiers invalid in parameter declarations");
10303       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10304         {
10305           if (decl_context == PARM)
10306             error ("typedef declaration invalid in parameter declaration");
10307           nclasses++;
10308         }
10309       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
10310       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
10311     }
10312
10313   /* Give error if `virtual' is used outside of class declaration.  */
10314   if (virtualp
10315       && (current_class_name == NULL_TREE || decl_context != FIELD))
10316     {
10317       error ("virtual outside class declaration");
10318       virtualp = 0;
10319     }
10320
10321   /* Static anonymous unions are dealt with here.  */
10322   if (staticp && decl_context == TYPENAME
10323       && TREE_CODE (declspecs) == TREE_LIST
10324       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
10325     decl_context = FIELD;
10326
10327   /* Warn about storage classes that are invalid for certain
10328      kinds of declarations (parameters, typenames, etc.).  */
10329
10330   if (nclasses > 1)
10331     error ("multiple storage classes in declaration of `%s'", name);
10332   else if (decl_context != NORMAL && nclasses > 0)
10333     {
10334       if ((decl_context == PARM || decl_context == CATCHPARM)
10335           && (RIDBIT_SETP (RID_REGISTER, specbits)
10336               || RIDBIT_SETP (RID_AUTO, specbits)))
10337         ;
10338       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10339         ;
10340       else if (decl_context == FIELD
10341                /* C++ allows static class elements  */
10342                && RIDBIT_SETP (RID_STATIC, specbits))
10343         /* C++ also allows inlines and signed and unsigned elements,
10344            but in those cases we don't come in here.  */
10345         ;
10346       else
10347         {
10348           if (decl_context == FIELD)
10349             {
10350               tree tmp = NULL_TREE;
10351               register int op = 0;
10352
10353               if (declarator)
10354                 {
10355                   /* Avoid trying to get an operand off an identifier node.  */
10356                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10357                     tmp = declarator;
10358                   else
10359                     tmp = TREE_OPERAND (declarator, 0);
10360                   op = IDENTIFIER_OPNAME_P (tmp);
10361                   if (IDENTIFIER_TYPENAME_P (tmp))
10362                     {
10363                       if (IDENTIFIER_GLOBAL_VALUE (tmp)
10364                           && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (tmp))
10365                               == TYPE_DECL))
10366                         name = IDENTIFIER_POINTER (tmp);
10367                       else
10368                         name = "<invalid operator>";
10369                     }
10370                 }
10371               error ("storage class specified for %s `%s'",
10372                      op ? "member operator" : "field",
10373                      name);
10374             }
10375           else
10376             {
10377               if (decl_context == PARM || decl_context == CATCHPARM)
10378                 error ("storage class specified for parameter `%s'", name);
10379               else
10380                 error ("storage class specified for typename");
10381             }
10382           RIDBIT_RESET (RID_REGISTER, specbits);
10383           RIDBIT_RESET (RID_AUTO, specbits);
10384           RIDBIT_RESET (RID_EXTERN, specbits);
10385         }
10386     }
10387   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10388     {
10389       if (toplevel_bindings_p ())
10390         {
10391           /* It's common practice (and completely valid) to have a const
10392              be initialized and declared extern.  */
10393           if (!(type_quals & TYPE_QUAL_CONST))
10394             warning ("`%s' initialized and declared `extern'", name);
10395         }
10396       else
10397         error ("`%s' has both `extern' and initializer", name);
10398     }
10399   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10400            && ! toplevel_bindings_p ())
10401     error ("nested function `%s' declared `extern'", name);
10402   else if (toplevel_bindings_p ())
10403     {
10404       if (RIDBIT_SETP (RID_AUTO, specbits))
10405         error ("top-level declaration of `%s' specifies `auto'", name);
10406     }
10407
10408   if (nclasses > 0 && friendp)
10409     error ("storage class specifiers invalid in friend function declarations");
10410
10411   /* Now figure out the structure of the declarator proper.
10412      Descend through it, creating more complex types, until we reach
10413      the declared identifier (or NULL_TREE, in an absolute declarator).  */
10414
10415   inner_attrs = NULL_TREE;
10416   ignore_attrs = 0;
10417
10418   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10419          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10420     {
10421       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10422          an INDIRECT_REF (for *...),
10423          a CALL_EXPR (for ...(...)),
10424          an identifier (for the name being declared)
10425          or a null pointer (for the place in an absolute declarator
10426          where the name was omitted).
10427          For the last two cases, we have just exited the loop.
10428
10429          For C++ it could also be
10430          a SCOPE_REF (for class :: ...).  In this case, we have converted
10431          sensible names to types, and those are the values we use to
10432          qualify the member name.
10433          an ADDR_EXPR (for &...),
10434          a BIT_NOT_EXPR (for destructors)
10435
10436          At this point, TYPE is the type of elements of an array,
10437          or for a function to return, or for a pointer to point to.
10438          After this sequence of ifs, TYPE is the type of the
10439          array or function or pointer, and DECLARATOR has had its
10440          outermost layer removed.  */
10441
10442       if (type == error_mark_node)
10443         {
10444           if (TREE_CODE (declarator) == SCOPE_REF)
10445             declarator = TREE_OPERAND (declarator, 1);
10446           else
10447             declarator = TREE_OPERAND (declarator, 0);
10448           continue;
10449         }
10450       if (quals != NULL_TREE
10451           && (declarator == NULL_TREE
10452               || TREE_CODE (declarator) != SCOPE_REF))
10453         {
10454           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10455             ctype = TYPE_METHOD_BASETYPE (type);
10456           if (ctype != NULL_TREE)
10457             {
10458               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10459               grok_method_quals (ctype, dummy, quals);
10460               type = TREE_TYPE (dummy);
10461               ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
10462               quals = NULL_TREE;
10463             }
10464         }
10465
10466       /* See the comment for the TREE_LIST case, below.  */
10467       if (ignore_attrs)
10468         ignore_attrs = 0;
10469       else if (inner_attrs)
10470         {
10471           decl_attributes (type, inner_attrs, NULL_TREE);
10472           inner_attrs = NULL_TREE;
10473         }
10474
10475       switch (TREE_CODE (declarator))
10476         {
10477         case TREE_LIST:
10478           {
10479             /* We encode a declarator with embedded attributes using
10480                a TREE_LIST.  The attributes apply to the declarator
10481                directly inside them, so we have to skip an iteration
10482                before applying them to the type.  If the declarator just
10483                inside is the declarator-id, we apply the attrs to the
10484                decl itself.  */
10485             inner_attrs = TREE_PURPOSE (declarator);
10486             ignore_attrs = 1;
10487             declarator = TREE_VALUE (declarator);
10488           }
10489           break;
10490
10491         case ARRAY_REF:
10492           {
10493             register tree size;
10494
10495             size = TREE_OPERAND (declarator, 1);
10496
10497             /* VC++ spells a zero-sized array with [].  */
10498             if (size == NULL_TREE && decl_context == FIELD && ! staticp
10499                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10500               size = integer_zero_node;
10501
10502             declarator = TREE_OPERAND (declarator, 0);
10503
10504             type = create_array_type_for_decl (dname, type, size);
10505
10506             /* VLAs never work as fields. */
10507             if (decl_context == FIELD && !processing_template_decl
10508                 && TREE_CODE (type) == ARRAY_TYPE
10509                 && TYPE_DOMAIN (type) != NULL_TREE
10510                 && !TREE_CONSTANT (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
10511               {
10512                 cp_error ("size of member `%D' is not constant", dname);
10513                 /* Proceed with arbitrary constant size, so that offset
10514                    computations don't get confused. */
10515                 type = create_array_type_for_decl (dname, TREE_TYPE (type),
10516                                                    integer_one_node);
10517               }
10518
10519             ctype = NULL_TREE;
10520           }
10521           break;
10522
10523         case CALL_EXPR:
10524           {
10525             tree arg_types;
10526             int funcdecl_p;
10527             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10528             tree inner_decl = TREE_OPERAND (declarator, 0);
10529
10530             /* Declaring a function type.
10531                Make sure we have a valid type for the function to return.  */
10532
10533             /* We now know that the TYPE_QUALS don't apply to the
10534                decl, but to its return type.  */
10535             type_quals = TYPE_UNQUALIFIED;
10536
10537             /* Warn about some types functions can't return.  */
10538
10539             if (TREE_CODE (type) == FUNCTION_TYPE)
10540               {
10541                 error ("`%s' declared as function returning a function", name);
10542                 type = integer_type_node;
10543               }
10544             if (TREE_CODE (type) == ARRAY_TYPE)
10545               {
10546                 error ("`%s' declared as function returning an array", name);
10547                 type = integer_type_node;
10548               }
10549
10550             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10551               inner_decl = TREE_OPERAND (inner_decl, 1);
10552
10553             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10554               inner_decl = dname;
10555
10556             /* Pick up type qualifiers which should be applied to `this'.  */
10557             quals = CALL_DECLARATOR_QUALS (declarator);
10558
10559             /* Pick up the exception specifications.  */
10560             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10561
10562             /* Say it's a definition only for the CALL_EXPR
10563                closest to the identifier.  */
10564             funcdecl_p
10565               = inner_decl
10566               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10567                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10568                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10569
10570             if (ctype == NULL_TREE
10571                 && decl_context == FIELD
10572                 && funcdecl_p
10573                 && (friendp == 0 || dname == current_class_name))
10574               ctype = current_class_type;
10575
10576             if (ctype && sfk == sfk_conversion)
10577               TYPE_HAS_CONVERSION (ctype) = 1;
10578             if (ctype && constructor_name (ctype) == dname)
10579               {
10580                 /* We are within a class's scope. If our declarator name
10581                    is the same as the class name, and we are defining
10582                    a function, then it is a constructor/destructor, and
10583                    therefore returns a void type.  */
10584
10585                 if (flags == DTOR_FLAG)
10586                   {
10587                     /* ISO C++ 12.4/2.  A destructor may not be
10588                        declared const or volatile.  A destructor may
10589                        not be static.  */
10590                     if (staticp == 2)
10591                       error ("destructor cannot be static member function");
10592                     if (quals)
10593                       {
10594                         cp_error ("destructors may not be `%s'",
10595                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10596                         quals = NULL_TREE;
10597                       }
10598                     if (decl_context == FIELD)
10599                       {
10600                         if (! member_function_or_else (ctype,
10601                                                        current_class_type,
10602                                                        flags))
10603                           return void_type_node;
10604                       }
10605                   }
10606                 else            /* It's a constructor.  */
10607                   {
10608                     if (explicitp == 1)
10609                       explicitp = 2;
10610                     /* ISO C++ 12.1.  A constructor may not be
10611                        declared const or volatile.  A constructor may
10612                        not be virtual.  A constructor may not be
10613                        static.  */
10614                     if (staticp == 2)
10615                       error ("constructor cannot be static member function");
10616                     if (virtualp)
10617                       {
10618                         pedwarn ("constructors cannot be declared virtual");
10619                         virtualp = 0;
10620                       }
10621                     if (quals)
10622                       {
10623                         cp_error ("constructors may not be `%s'",
10624                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10625                         quals = NULL_TREE;
10626                       }
10627                     {
10628                       RID_BIT_TYPE tmp_bits;
10629                       bcopy ((void*)&specbits, (void*)&tmp_bits, sizeof (RID_BIT_TYPE));
10630                       RIDBIT_RESET (RID_INLINE, tmp_bits);
10631                       RIDBIT_RESET (RID_STATIC, tmp_bits);
10632                       if (RIDBIT_ANY_SET (tmp_bits))
10633                         error ("return value type specifier for constructor ignored");
10634                     }
10635                     if (decl_context == FIELD)
10636                       {
10637                         if (! member_function_or_else (ctype,
10638                                                        current_class_type,
10639                                                        flags))
10640                           return void_type_node;
10641                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10642                         if (sfk != sfk_constructor)
10643                           return NULL_TREE;
10644                       }
10645                   }
10646                 if (decl_context == FIELD)
10647                   staticp = 0;
10648               }
10649             else if (friendp)
10650               {
10651                 if (initialized)
10652                   error ("can't initialize friend function `%s'", name);
10653                 if (virtualp)
10654                   {
10655                     /* Cannot be both friend and virtual.  */
10656                     error ("virtual functions cannot be friends");
10657                     RIDBIT_RESET (RID_FRIEND, specbits);
10658                     friendp = 0;
10659                   }
10660                 if (decl_context == NORMAL)
10661                   error ("friend declaration not in class definition");
10662                 if (current_function_decl && funcdef_flag)
10663                   cp_error ("can't define friend function `%s' in a local class definition",
10664                             name);
10665               }
10666
10667             /* Construct the function type and go to the next
10668                inner layer of declarator.  */
10669
10670             declarator = TREE_OPERAND (declarator, 0);
10671
10672             /* FIXME: This is where default args should be fully
10673                processed.  */
10674
10675             arg_types = grokparms (inner_parms, funcdecl_p ? funcdef_flag : 0);
10676
10677             if (declarator && flags == DTOR_FLAG)
10678               {
10679                 /* A destructor declared in the body of a class will
10680                    be represented as a BIT_NOT_EXPR.  But, we just
10681                    want the underlying IDENTIFIER.  */
10682                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10683                   declarator = TREE_OPERAND (declarator, 0);
10684
10685                 if (arg_types != void_list_node)
10686                   {
10687                     cp_error ("destructors may not have parameters");
10688                     arg_types = void_list_node;
10689                     last_function_parms = NULL_TREE;
10690                   }
10691               }
10692
10693             /* ANSI says that `const int foo ();'
10694                does not make the function foo const.  */
10695             type = build_function_type (type, arg_types);
10696
10697             {
10698               tree t;
10699               for (t = arg_types; t; t = TREE_CHAIN (t))
10700                 if (TREE_PURPOSE (t)
10701                     && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10702                   {
10703                     add_defarg_fn (type);
10704                     break;
10705                   }
10706             }
10707           }
10708           break;
10709
10710         case ADDR_EXPR:
10711         case INDIRECT_REF:
10712           /* Filter out pointers-to-references and references-to-references.
10713              We can get these if a TYPE_DECL is used.  */
10714
10715           if (TREE_CODE (type) == REFERENCE_TYPE)
10716             {
10717               error ("cannot declare %s to references",
10718                      TREE_CODE (declarator) == ADDR_EXPR
10719                      ? "references" : "pointers");
10720               declarator = TREE_OPERAND (declarator, 0);
10721               continue;
10722             }
10723
10724           if (TREE_CODE (type) == OFFSET_TYPE
10725               && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10726                   || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10727             {
10728               cp_error ("cannot declare pointer to `%#T' member",
10729                         TREE_TYPE (type));
10730               type = TREE_TYPE (type);
10731             }
10732
10733           /* Merge any constancy or volatility into the target type
10734              for the pointer.  */
10735
10736           /* We now know that the TYPE_QUALS don't apply to the decl,
10737              but to the target of the pointer.  */
10738           type_quals = TYPE_UNQUALIFIED;
10739
10740           if (TREE_CODE (declarator) == ADDR_EXPR)
10741             {
10742               if (TREE_CODE (type) == VOID_TYPE)
10743                 error ("invalid type: `void &'");
10744               else
10745                 type = build_reference_type (type);
10746             }
10747           else if (TREE_CODE (type) == METHOD_TYPE)
10748             type = build_ptrmemfunc_type (build_pointer_type (type));
10749           else
10750             type = build_pointer_type (type);
10751
10752           /* Process a list of type modifier keywords (such as
10753              const or volatile) that were given inside the `*' or `&'.  */
10754
10755           if (TREE_TYPE (declarator))
10756             {
10757               register tree typemodlist;
10758               int erred = 0;
10759
10760               constp = 0;
10761               volatilep = 0;
10762               restrictp = 0;
10763               for (typemodlist = TREE_TYPE (declarator); typemodlist;
10764                    typemodlist = TREE_CHAIN (typemodlist))
10765                 {
10766                   tree qualifier = TREE_VALUE (typemodlist);
10767
10768                   if (qualifier == ridpointers[(int) RID_CONST])
10769                     constp++;
10770                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
10771                     volatilep++;
10772                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
10773                     restrictp++;
10774                   else if (!erred)
10775                     {
10776                       erred = 1;
10777                       error ("invalid type modifier within pointer declarator");
10778                     }
10779                 }
10780               if (constp > 1)
10781                 pedwarn ("duplicate `const'");
10782               if (volatilep > 1)
10783                 pedwarn ("duplicate `volatile'");
10784               if (restrictp > 1)
10785                 pedwarn ("duplicate `restrict'");
10786
10787               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10788                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10789                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10790               if (TREE_CODE (declarator) == ADDR_EXPR
10791                   && (constp || volatilep))
10792                 {
10793                   if (constp)
10794                     pedwarn ("discarding `const' applied to a reference");
10795                   if (volatilep)
10796                     pedwarn ("discarding `volatile' applied to a reference");
10797                   type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
10798                 }
10799               type = cp_build_qualified_type (type, type_quals);
10800             }
10801           declarator = TREE_OPERAND (declarator, 0);
10802           ctype = NULL_TREE;
10803           break;
10804
10805         case SCOPE_REF:
10806           {
10807             /* We have converted type names to NULL_TREE if the
10808                name was bogus, or to a _TYPE node, if not.
10809
10810                The variable CTYPE holds the type we will ultimately
10811                resolve to.  The code here just needs to build
10812                up appropriate member types.  */
10813             tree sname = TREE_OPERAND (declarator, 1);
10814             tree t;
10815
10816             /* Destructors can have their visibilities changed as well.  */
10817             if (TREE_CODE (sname) == BIT_NOT_EXPR)
10818               sname = TREE_OPERAND (sname, 0);
10819
10820             if (TREE_COMPLEXITY (declarator) == 0)
10821               /* This needs to be here, in case we are called
10822                  multiple times.  */ ;
10823             else if (TREE_COMPLEXITY (declarator) == -1)
10824               /* Namespace member. */
10825               pop_decl_namespace ();
10826             else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
10827               /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10828             else if (! IS_AGGR_TYPE_CODE
10829                      (TREE_CODE (TREE_OPERAND (declarator, 0))))
10830               ;
10831             else if (TREE_COMPLEXITY (declarator) == current_class_depth)
10832               {
10833                 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10834                    that refer to ctype.  They couldn't be resolved earlier
10835                    because we hadn't pushed into the class yet.
10836                    Example: resolve 'B<T>::type' in
10837                    'B<typename B<T>::type> B<T>::f () { }'.  */
10838                 if (current_template_parms
10839                     && uses_template_parms (type)
10840                     && uses_template_parms (current_class_type))
10841                   {
10842                     tree args = current_template_args ();
10843                     type = tsubst (type, args, /*complain=*/1, NULL_TREE);
10844                   }
10845
10846                 /* This pop_nested_class corresponds to the
10847                    push_nested_class used to push into class scope for
10848                    parsing the argument list of a function decl, in
10849                    qualified_id.  */
10850                 pop_nested_class ();
10851                 TREE_COMPLEXITY (declarator) = current_class_depth;
10852               }
10853             else
10854               my_friendly_abort (16);
10855
10856             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
10857               {
10858                 /* We had a reference to a global decl, or
10859                    perhaps we were given a non-aggregate typedef,
10860                    in which case we cleared this out, and should just
10861                    keep going as though it wasn't there.  */
10862                 declarator = sname;
10863                 continue;
10864               }
10865             ctype = TREE_OPERAND (declarator, 0);
10866
10867             t = ctype;
10868             while (t != NULL_TREE && CLASS_TYPE_P (t))
10869               {
10870                 /* You're supposed to have one `template <...>'
10871                    for every template class, but you don't need one
10872                    for a full specialization.  For example:
10873
10874                      template <class T> struct S{};
10875                      template <> struct S<int> { void f(); };
10876                      void S<int>::f () {}
10877
10878                    is correct; there shouldn't be a `template <>' for
10879                    the definition of `S<int>::f'.  */
10880                 if (CLASSTYPE_TEMPLATE_INFO (t)
10881                     && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
10882                         || uses_template_parms (CLASSTYPE_TI_ARGS (t))))
10883                   template_count += 1;
10884
10885                 t = TYPE_MAIN_DECL (t);
10886                 if (DECL_LANG_SPECIFIC (t))
10887                   t = DECL_CONTEXT (t);
10888                 else
10889                   t = NULL_TREE;
10890               }
10891
10892             if (sname == NULL_TREE)
10893               goto done_scoping;
10894
10895             if (TREE_CODE (sname) == IDENTIFIER_NODE)
10896               {
10897                 /* This is the `standard' use of the scoping operator:
10898                    basetype :: member .  */
10899
10900                 if (ctype == current_class_type)
10901                   {
10902                     /* class A {
10903                          void A::f ();
10904                        };
10905
10906                        Is this ill-formed?  */
10907
10908                     if (pedantic)
10909                       cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10910                                   ctype, name);
10911                   }
10912                 else if (TREE_CODE (type) == FUNCTION_TYPE)
10913                   {
10914                     if (current_class_type == NULL_TREE
10915                         || friendp)
10916                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10917                                                       TYPE_ARG_TYPES (type));
10918                     else
10919                       {
10920                         cp_error ("cannot declare member function `%T::%s' within `%T'",
10921                                   ctype, name, current_class_type);
10922                         return void_type_node;
10923                       }
10924                   }
10925                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
10926                          || COMPLETE_TYPE_P (complete_type (ctype)))
10927                   {
10928                     /* Have to move this code elsewhere in this function.
10929                        this code is used for i.e., typedef int A::M; M *pm;
10930
10931                        It is?  How? jason 10/2/94 */
10932
10933                     if (current_class_type)
10934                       {
10935                         cp_error ("cannot declare member `%T::%s' within `%T'",
10936                                   ctype, name, current_class_type);
10937                         return void_type_node;
10938                       }
10939                     type = build_offset_type (ctype, type);
10940                   }
10941                 else if (uses_template_parms (ctype))
10942                   {
10943                     if (TREE_CODE (type) == FUNCTION_TYPE)
10944                       type
10945                         = build_cplus_method_type (ctype, TREE_TYPE (type),
10946                                                    TYPE_ARG_TYPES (type));
10947                   }
10948                 else
10949                   {
10950                     cp_error ("structure `%T' not yet defined", ctype);
10951                     return error_mark_node;
10952                   }
10953
10954                 declarator = sname;
10955               }
10956             else if (TREE_CODE (sname) == SCOPE_REF)
10957               my_friendly_abort (17);
10958             else
10959               {
10960               done_scoping:
10961                 declarator = TREE_OPERAND (declarator, 1);
10962                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
10963                   /* In this case, we will deal with it later.  */
10964                   ;
10965                 else
10966                   {
10967                     if (TREE_CODE (type) == FUNCTION_TYPE)
10968                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10969                                                       TYPE_ARG_TYPES (type));
10970                     else
10971                       type = build_offset_type (ctype, type);
10972                   }
10973               }
10974           }
10975           break;
10976
10977         case BIT_NOT_EXPR:
10978           declarator = TREE_OPERAND (declarator, 0);
10979           break;
10980
10981         case RECORD_TYPE:
10982         case UNION_TYPE:
10983         case ENUMERAL_TYPE:
10984           declarator = NULL_TREE;
10985           break;
10986
10987         case ERROR_MARK:
10988           declarator = NULL_TREE;
10989           break;
10990
10991         default:
10992           my_friendly_abort (158);
10993         }
10994     }
10995
10996   /* See the comment for the TREE_LIST case, above.  */
10997   if (inner_attrs)
10998     {
10999       if (! ignore_attrs)
11000         decl_attributes (type, inner_attrs, NULL_TREE);
11001       else if (attrlist)
11002         TREE_VALUE (attrlist) = chainon (inner_attrs, TREE_VALUE (attrlist));
11003       else
11004         attrlist = build_decl_list (NULL_TREE, inner_attrs);
11005     }
11006
11007   /* Now TYPE has the actual type.  */
11008
11009   if (explicitp == 1 || (explicitp && friendp))
11010     {
11011       /* [dcl.fct.spec] The explicit specifier shall only be used in
11012          declarations of constructors within a class definition.  */
11013       error ("only declarations of constructors can be `explicit'");
11014       explicitp = 0;
11015     }
11016
11017   if (RIDBIT_SETP (RID_MUTABLE, specbits))
11018     {
11019       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
11020         {
11021           error ("non-member `%s' cannot be declared `mutable'", name);
11022           RIDBIT_RESET (RID_MUTABLE, specbits);
11023         }
11024       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
11025         {
11026           error ("non-object member `%s' cannot be declared `mutable'", name);
11027           RIDBIT_RESET (RID_MUTABLE, specbits);
11028         }
11029       else if (TREE_CODE (type) == FUNCTION_TYPE
11030                || TREE_CODE (type) == METHOD_TYPE)
11031         {
11032           error ("function `%s' cannot be declared `mutable'", name);
11033           RIDBIT_RESET (RID_MUTABLE, specbits);
11034         }
11035       else if (staticp)
11036         {
11037           error ("static `%s' cannot be declared `mutable'", name);
11038           RIDBIT_RESET (RID_MUTABLE, specbits);
11039         }
11040       else if (type_quals & TYPE_QUAL_CONST)
11041         {
11042           error ("const `%s' cannot be declared `mutable'", name);
11043           RIDBIT_RESET (RID_MUTABLE, specbits);
11044         }
11045     }
11046
11047   if (declarator == NULL_TREE
11048       || TREE_CODE (declarator) == IDENTIFIER_NODE
11049       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
11050           && (TREE_CODE (type) == FUNCTION_TYPE
11051               || TREE_CODE (type) == METHOD_TYPE)))
11052     /* OK */;
11053   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11054     {
11055       cp_error ("template-id `%D' used as a declarator", declarator);
11056       declarator = dname;
11057     }
11058   else
11059     /* Unexpected declarator format.  */
11060     my_friendly_abort (990210);
11061
11062   /* If this is declaring a typedef name, return a TYPE_DECL.  */
11063
11064   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
11065     {
11066       tree decl;
11067
11068       /* Note that the grammar rejects storage classes
11069          in typenames, fields or parameters.  */
11070       if (current_lang_name == lang_name_java)
11071         TYPE_FOR_JAVA (type) = 1;
11072
11073       if (decl_context == FIELD)
11074         {
11075           if (declarator == constructor_name (current_class_type))
11076             cp_pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
11077                         declarator);
11078           decl = build_lang_decl (TYPE_DECL, declarator, type);
11079         }
11080       else
11081         decl = build_decl (TYPE_DECL, declarator, type);
11082
11083       /* If the user declares "typedef struct {...} foo" then the
11084          struct will have an anonymous name.  Fill that name in now.
11085          Nothing can refer to it, so nothing needs know about the name
11086          change.  */
11087       if (type != error_mark_node
11088           && declarator
11089           && TYPE_NAME (type)
11090           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11091           && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type))
11092           && CP_TYPE_QUALS (type) == TYPE_UNQUALIFIED)
11093         {
11094           tree oldname = TYPE_NAME (type);
11095           tree t;
11096
11097           /* Replace the anonymous name with the real name everywhere.  */
11098           lookup_tag_reverse (type, declarator);
11099           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
11100             if (TYPE_NAME (t) == oldname)
11101               TYPE_NAME (t) = decl;
11102
11103           if (TYPE_LANG_SPECIFIC (type))
11104             TYPE_WAS_ANONYMOUS (type) = 1;
11105
11106           /* If this is a typedef within a template class, the nested
11107              type is a (non-primary) template.  The name for the
11108              template needs updating as well.  */
11109           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
11110             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
11111               = TYPE_IDENTIFIER (type);
11112
11113           if (flag_new_abi)
11114             DECL_ASSEMBLER_NAME (decl) = mangle_type (type);
11115           else
11116             {
11117               /* XXX Temporarily set the scope.
11118                  When returning, start_decl expects it as NULL_TREE,
11119                  and will then then set it using pushdecl. */
11120               my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 980404);
11121               if (current_class_type)
11122                 DECL_CONTEXT (decl) = current_class_type;
11123               else
11124                 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
11125
11126               DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
11127               DECL_ASSEMBLER_NAME (decl)
11128                 = get_identifier (build_overload_name (type, 1, 1));
11129               DECL_CONTEXT (decl) = NULL_TREE;
11130             }
11131
11132           /* FIXME remangle member functions; member functions of a
11133              type with external linkage have external linkage.  */
11134         }
11135
11136       if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
11137         {
11138           cp_error_at ("typedef name may not be class-qualified", decl);
11139           return NULL_TREE;
11140         }
11141       else if (quals)
11142         {
11143           if (ctype == NULL_TREE)
11144             {
11145               if (TREE_CODE (type) != METHOD_TYPE)
11146                 cp_error_at ("invalid type qualifier for non-member function type", decl);
11147               else
11148                 ctype = TYPE_METHOD_BASETYPE (type);
11149             }
11150           if (ctype != NULL_TREE)
11151             grok_method_quals (ctype, decl, quals);
11152         }
11153
11154       if (RIDBIT_SETP (RID_SIGNED, specbits)
11155           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
11156         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
11157
11158       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
11159                       inlinep, friendp, raises != NULL_TREE);
11160
11161       if (initialized)
11162         error ("typedef declaration includes an initializer");
11163
11164       return decl;
11165     }
11166
11167   /* Detect the case of an array type of unspecified size
11168      which came, as such, direct from a typedef name.
11169      We must copy the type, so that each identifier gets
11170      a distinct type, so that each identifier's size can be
11171      controlled separately by its own initializer.  */
11172
11173   if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
11174       && TYPE_DOMAIN (type) == NULL_TREE)
11175     {
11176       type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
11177     }
11178
11179   /* If this is a type name (such as, in a cast or sizeof),
11180      compute the type and return it now.  */
11181
11182   if (decl_context == TYPENAME)
11183     {
11184       /* Note that the grammar rejects storage classes
11185          in typenames, fields or parameters.  */
11186       if (type_quals != TYPE_UNQUALIFIED)
11187         type_quals = TYPE_UNQUALIFIED;
11188
11189       /* Special case: "friend class foo" looks like a TYPENAME context.  */
11190       if (friendp)
11191         {
11192           if (type_quals != TYPE_UNQUALIFIED)
11193             {
11194               cp_error ("type qualifiers specified for friend class declaration");
11195               type_quals = TYPE_UNQUALIFIED;
11196             }
11197           if (inlinep)
11198             {
11199               cp_error ("`inline' specified for friend class declaration");
11200               inlinep = 0;
11201             }
11202
11203           /* Only try to do this stuff if we didn't already give up.  */
11204           if (type != integer_type_node)
11205             {
11206               /* A friendly class?  */
11207               if (current_class_type)
11208                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
11209               else
11210                 error ("trying to make class `%s' a friend of global scope",
11211                        TYPE_NAME_STRING (type));
11212               type = void_type_node;
11213             }
11214         }
11215       else if (quals)
11216         {
11217           if (ctype == NULL_TREE)
11218             {
11219               if (TREE_CODE (type) != METHOD_TYPE)
11220                 cp_error ("invalid qualifiers on non-member function type");
11221               else
11222                 ctype = TYPE_METHOD_BASETYPE (type);
11223             }
11224           if (ctype)
11225             {
11226               tree dummy = build_decl (TYPE_DECL, declarator, type);
11227               grok_method_quals (ctype, dummy, quals);
11228               type = TREE_TYPE (dummy);
11229             }
11230         }
11231
11232       return type;
11233     }
11234   else if (declarator == NULL_TREE && decl_context != PARM
11235            && decl_context != CATCHPARM
11236            && TREE_CODE (type) != UNION_TYPE
11237            && ! bitfield)
11238     {
11239       cp_error ("abstract declarator `%T' used as declaration", type);
11240       declarator = make_anon_name ();
11241     }
11242
11243   /* `void' at top level (not within pointer)
11244      is allowed only in typedefs or type names.
11245      We don't complain about parms either, but that is because
11246      a better error message can be made later.  */
11247
11248   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
11249     {
11250       if (! declarator)
11251         error ("unnamed variable or field declared void");
11252       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
11253         {
11254           if (IDENTIFIER_OPNAME_P (declarator))
11255             my_friendly_abort (356);
11256           else
11257             error ("variable or field `%s' declared void", name);
11258         }
11259       else
11260         error ("variable or field declared void");
11261       type = integer_type_node;
11262     }
11263
11264   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11265      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
11266
11267   if (decl_context == PARM || decl_context == CATCHPARM)
11268     {
11269       if (ctype || in_namespace)
11270         error ("cannot use `::' in parameter declaration");
11271
11272       /* A parameter declared as an array of T is really a pointer to T.
11273          One declared as a function is really a pointer to a function.
11274          One declared as a member is really a pointer to member.  */
11275
11276       if (TREE_CODE (type) == ARRAY_TYPE)
11277         {
11278           /* Transfer const-ness of array into that of type pointed to.  */
11279           type = build_pointer_type (TREE_TYPE (type));
11280           type_quals = TYPE_UNQUALIFIED;
11281         }
11282       else if (TREE_CODE (type) == FUNCTION_TYPE)
11283         type = build_pointer_type (type);
11284       else if (TREE_CODE (type) == OFFSET_TYPE)
11285         type = build_pointer_type (type);
11286       else if (TREE_CODE (type) == VOID_TYPE && declarator)
11287         {
11288           error ("declaration of `%s' as void", name);
11289           return NULL_TREE;
11290         }
11291     }
11292
11293   {
11294     register tree decl;
11295
11296     if (decl_context == PARM)
11297       {
11298         decl = build_decl (PARM_DECL, declarator, type);
11299
11300         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
11301                         inlinep, friendp, raises != NULL_TREE);
11302
11303         /* Compute the type actually passed in the parmlist,
11304            for the case where there is no prototype.
11305            (For example, shorts and chars are passed as ints.)
11306            When there is a prototype, this is overridden later.  */
11307
11308         DECL_ARG_TYPE (decl) = type_promotes_to (type);
11309       }
11310     else if (decl_context == FIELD)
11311       {
11312         if (type == error_mark_node)
11313           {
11314             /* Happens when declaring arrays of sizes which
11315                are error_mark_node, for example.  */
11316             decl = NULL_TREE;
11317           }
11318         else if (in_namespace && !friendp)
11319           {
11320             /* Something like struct S { int N::j; };  */
11321             cp_error ("invalid use of `::'");
11322             decl = NULL_TREE;
11323           }
11324         else if (TREE_CODE (type) == FUNCTION_TYPE)
11325           {
11326             int publicp = 0;
11327             tree function_context;
11328
11329             /* We catch the others as conflicts with the builtin
11330                typedefs.  */
11331             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11332               {
11333                 cp_error ("function `%D' cannot be declared friend",
11334                           declarator);
11335                 friendp = 0;
11336               }
11337
11338             if (friendp == 0)
11339               {
11340                 if (ctype == NULL_TREE)
11341                   ctype = current_class_type;
11342
11343                 if (ctype == NULL_TREE)
11344                   {
11345                     cp_error ("can't make `%D' into a method -- not in a class",
11346                               declarator);
11347                     return void_type_node;
11348                   }
11349
11350                 /* ``A union may [ ... ] not [ have ] virtual functions.''
11351                    ARM 9.5 */
11352                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11353                   {
11354                     cp_error ("function `%D' declared virtual inside a union",
11355                               declarator);
11356                     return void_type_node;
11357                   }
11358
11359                 if (declarator == ansi_opname (NEW_EXPR)
11360                     || declarator == ansi_opname (VEC_NEW_EXPR)
11361                     || declarator == ansi_opname (DELETE_EXPR)
11362                     || declarator == ansi_opname (VEC_DELETE_EXPR))
11363                   {
11364                     if (virtualp)
11365                       {
11366                         cp_error ("`%D' cannot be declared virtual, since it is always static",
11367                                   declarator);
11368                         virtualp = 0;
11369                       }
11370                   }
11371                 else if (staticp < 2)
11372                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11373                                                   TYPE_ARG_TYPES (type));
11374               }
11375
11376             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
11377             function_context = (ctype != NULL_TREE) ?
11378               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11379             publicp = (! friendp || ! staticp)
11380               && function_context == NULL_TREE;
11381             decl = grokfndecl (ctype, type,
11382                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11383                                ? declarator : dname,
11384                                declarator,
11385                                virtualp, flags, quals, raises,
11386                                friendp ? -1 : 0, friendp, publicp, inlinep,
11387                                funcdef_flag, template_count, in_namespace);
11388             if (decl == NULL_TREE)
11389               return decl;
11390 #if 0
11391             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
11392             /* The decl and setting of decl_machine_attr is also turned off.  */
11393             decl = build_decl_attribute_variant (decl, decl_machine_attr);
11394 #endif
11395
11396             /* [class.conv.ctor]
11397
11398                A constructor declared without the function-specifier
11399                explicit that can be called with a single parameter
11400                specifies a conversion from the type of its first
11401                parameter to the type of its class.  Such a constructor
11402                is called a converting constructor.  */
11403             if (explicitp == 2)
11404               DECL_NONCONVERTING_P (decl) = 1;
11405             else if (DECL_CONSTRUCTOR_P (decl))
11406               {
11407                 /* The constructor can be called with exactly one
11408                    parameter if there is at least one parameter, and
11409                    any subsequent parameters have default arguments.
11410                    We don't look at the first parameter, which is
11411                    really just the `this' parameter for the new
11412                    object.  */
11413                 tree arg_types =
11414                   TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)));
11415
11416                 /* Skip the `in_chrg' argument too, if present.  */
11417                 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
11418                   arg_types = TREE_CHAIN (arg_types);
11419
11420                 if (arg_types == void_list_node
11421                     || (arg_types
11422                         && TREE_CHAIN (arg_types)
11423                         && TREE_CHAIN (arg_types) != void_list_node
11424                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11425                   DECL_NONCONVERTING_P (decl) = 1;
11426               }
11427           }
11428         else if (TREE_CODE (type) == METHOD_TYPE)
11429           {
11430             /* We only get here for friend declarations of
11431                members of other classes.  */
11432             /* All method decls are public, so tell grokfndecl to set
11433                TREE_PUBLIC, also.  */
11434             decl = grokfndecl (ctype, type, declarator, declarator,
11435                                virtualp, flags, quals, raises,
11436                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11437                                template_count, in_namespace);
11438             if (decl == NULL_TREE)
11439               return NULL_TREE;
11440           }
11441         else if (!staticp && ! processing_template_decl
11442                  && !COMPLETE_TYPE_P (complete_type (type))
11443                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11444           {
11445             if (declarator)
11446               cp_error ("field `%D' has incomplete type", declarator);
11447             else
11448               cp_error ("name `%T' has incomplete type", type);
11449
11450             /* If we're instantiating a template, tell them which
11451                instantiation made the field's type be incomplete.  */
11452             if (current_class_type
11453                 && TYPE_NAME (current_class_type)
11454                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11455                 && declspecs && TREE_VALUE (declspecs)
11456                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11457               cp_error ("  in instantiation of template `%T'",
11458                         current_class_type);
11459
11460             type = error_mark_node;
11461             decl = NULL_TREE;
11462           }
11463         else
11464           {
11465             if (friendp)
11466               {
11467                 error ("`%s' is neither function nor member function; cannot be declared friend",
11468                        IDENTIFIER_POINTER (declarator));
11469                 friendp = 0;
11470               }
11471             decl = NULL_TREE;
11472           }
11473
11474         if (friendp)
11475           {
11476             /* Friends are treated specially.  */
11477             if (ctype == current_class_type)
11478               warning ("member functions are implicitly friends of their class");
11479             else
11480               {
11481                 tree t = NULL_TREE;
11482                 if (decl && DECL_NAME (decl))
11483                   {
11484                     if (template_class_depth (current_class_type) == 0)
11485                       {
11486                         decl
11487                           = check_explicit_specialization
11488                           (declarator, decl,
11489                            template_count, 2 * (funcdef_flag != 0) + 4);
11490                         if (decl == error_mark_node)
11491                           return error_mark_node;
11492                       }
11493
11494                     t = do_friend (ctype, declarator, decl,
11495                                    last_function_parms, attrlist, flags, quals,
11496                                    funcdef_flag);
11497                   }
11498                 if (t && funcdef_flag)
11499                   return t;
11500
11501                 return void_type_node;
11502               }
11503           }
11504
11505         /* Structure field.  It may not be a function, except for C++ */
11506
11507         if (decl == NULL_TREE)
11508           {
11509             if (initialized)
11510               {
11511                 if (!staticp)
11512                   {
11513                     /* An attempt is being made to initialize a non-static
11514                        member.  But, from [class.mem]:
11515
11516                        4 A member-declarator can contain a
11517                        constant-initializer only if it declares a static
11518                        member (_class.static_) of integral or enumeration
11519                        type, see _class.static.data_.
11520
11521                        This used to be relatively common practice, but
11522                        the rest of the compiler does not correctly
11523                        handle the initialization unless the member is
11524                        static so we make it static below.  */
11525                     cp_pedwarn ("ISO C++ forbids initialization of member `%D'",
11526                                 declarator);
11527                     cp_pedwarn ("making `%D' static", declarator);
11528                     staticp = 1;
11529                   }
11530
11531                 if (uses_template_parms (type))
11532                   /* We'll check at instantiation time.  */
11533                   ;
11534                 else if (check_static_variable_definition (declarator,
11535                                                            type))
11536                   /* If we just return the declaration, crashes
11537                      will sometimes occur.  We therefore return
11538                      void_type_node, as if this was a friend
11539                      declaration, to cause callers to completely
11540                      ignore this declaration.  */
11541                   return void_type_node;
11542               }
11543
11544             /* 9.2p13 [class.mem] */
11545             if (declarator == constructor_name (current_class_type)
11546                 /* The standard does not allow non-static data members
11547                    here either, but we agreed at the 10/99 meeting
11548                    to change that in TC 1 so that they are allowed in
11549                    classes with no user-defined constructors.  */
11550                 && staticp)
11551               cp_pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
11552                           declarator);
11553
11554             if (staticp)
11555               {
11556                 /* C++ allows static class members.  All other work
11557                    for this is done by grokfield.  */
11558                 decl = build_lang_decl (VAR_DECL, declarator, type);
11559                 TREE_STATIC (decl) = 1;
11560                 /* In class context, 'static' means public access.  */
11561                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11562               }
11563             else
11564               {
11565                 decl = build_decl (FIELD_DECL, declarator, type);
11566                 DECL_NONADDRESSABLE_P (decl) = bitfield;
11567                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11568                   {
11569                     DECL_MUTABLE_P (decl) = 1;
11570                     RIDBIT_RESET (RID_MUTABLE, specbits);
11571                   }
11572               }
11573
11574             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11575                             inlinep, friendp, raises != NULL_TREE);
11576           }
11577       }
11578     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11579       {
11580         tree original_name;
11581         int publicp = 0;
11582
11583         if (! declarator)
11584           return NULL_TREE;
11585
11586         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11587           original_name = dname;
11588         else
11589           original_name = declarator;
11590
11591         if (RIDBIT_SETP (RID_AUTO, specbits))
11592           error ("storage class `auto' invalid for function `%s'", name);
11593         else if (RIDBIT_SETP (RID_REGISTER, specbits))
11594           error ("storage class `register' invalid for function `%s'", name);
11595
11596         /* Function declaration not at top level.
11597            Storage classes other than `extern' are not allowed
11598            and `extern' makes no difference.  */
11599         if (! toplevel_bindings_p ()
11600             && (RIDBIT_SETP (RID_STATIC, specbits)
11601                 || RIDBIT_SETP (RID_INLINE, specbits))
11602             && pedantic)
11603           {
11604             if (RIDBIT_SETP (RID_STATIC, specbits))
11605               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11606             else
11607               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11608           }
11609
11610         if (ctype == NULL_TREE)
11611           {
11612             if (virtualp)
11613               {
11614                 error ("virtual non-class function `%s'", name);
11615                 virtualp = 0;
11616               }
11617           }
11618         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11619           type = build_cplus_method_type (ctype, TREE_TYPE (type),
11620                                           TYPE_ARG_TYPES (type));
11621
11622         /* Record presence of `static'.  */
11623         publicp = (ctype != NULL_TREE
11624                    || RIDBIT_SETP (RID_EXTERN, specbits)
11625                    || !RIDBIT_SETP (RID_STATIC, specbits));
11626
11627         decl = grokfndecl (ctype, type, original_name, declarator,
11628                            virtualp, flags, quals, raises,
11629                            1, friendp,
11630                            publicp, inlinep, funcdef_flag,
11631                            template_count, in_namespace);
11632         if (decl == NULL_TREE)
11633           return NULL_TREE;
11634
11635         if (staticp == 1)
11636           {
11637             int illegal_static = 0;
11638
11639             /* Don't allow a static member function in a class, and forbid
11640                declaring main to be static.  */
11641             if (TREE_CODE (type) == METHOD_TYPE)
11642               {
11643                 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11644                 illegal_static = 1;
11645               }
11646             else if (current_function_decl)
11647               {
11648                 /* FIXME need arm citation */
11649                 error ("cannot declare static function inside another function");
11650                 illegal_static = 1;
11651               }
11652
11653             if (illegal_static)
11654               {
11655                 staticp = 0;
11656                 RIDBIT_RESET (RID_STATIC, specbits);
11657               }
11658           }
11659       }
11660     else
11661       {
11662         /* It's a variable.  */
11663
11664         /* An uninitialized decl with `extern' is a reference.  */
11665         decl = grokvardecl (type, declarator, &specbits,
11666                             initialized,
11667                             (type_quals & TYPE_QUAL_CONST) != 0,
11668                             in_namespace);
11669         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11670                         inlinep, friendp, raises != NULL_TREE);
11671
11672         if (ctype)
11673           {
11674             DECL_CONTEXT (decl) = ctype;
11675             if (staticp == 1)
11676               {
11677                 cp_pedwarn ("static member `%D' re-declared as static", decl);
11678                 staticp = 0;
11679                 RIDBIT_RESET (RID_STATIC, specbits);
11680               }
11681             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11682               {
11683                 cp_error ("static member `%D' declared `register'", decl);
11684                 RIDBIT_RESET (RID_REGISTER, specbits);
11685               }
11686             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11687               {
11688                 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11689                             decl);
11690                 RIDBIT_RESET (RID_EXTERN, specbits);
11691               }
11692           }
11693       }
11694
11695     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11696
11697     /* Record `register' declaration for warnings on &
11698        and in case doing stupid register allocation.  */
11699
11700     if (RIDBIT_SETP (RID_REGISTER, specbits))
11701       DECL_REGISTER (decl) = 1;
11702
11703     if (RIDBIT_SETP (RID_EXTERN, specbits))
11704       DECL_THIS_EXTERN (decl) = 1;
11705
11706     if (RIDBIT_SETP (RID_STATIC, specbits))
11707       DECL_THIS_STATIC (decl) = 1;
11708
11709     /* Record constancy and volatility.  There's no need to do this
11710        when processing a template; we'll do this for the instantiated
11711        declaration based on the type of DECL.  */
11712     if (!processing_template_decl)
11713       c_apply_type_quals_to_decl (type_quals, decl);
11714
11715     return decl;
11716   }
11717 }
11718 \f
11719 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11720    An empty exprlist is a parmlist.  An exprlist which
11721    contains only identifiers at the global level
11722    is a parmlist.  Otherwise, it is an exprlist.  */
11723
11724 int
11725 parmlist_is_exprlist (exprs)
11726      tree exprs;
11727 {
11728   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11729     return 0;
11730
11731   if (toplevel_bindings_p ())
11732     {
11733       /* At the global level, if these are all identifiers,
11734          then it is a parmlist.  */
11735       while (exprs)
11736         {
11737           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11738             return 1;
11739           exprs = TREE_CHAIN (exprs);
11740         }
11741       return 0;
11742     }
11743   return 1;
11744 }
11745
11746 /* Subroutine of start_function.  Ensure that each of the parameter
11747    types (as listed in PARMS) is complete, as is required for a
11748    function definition.  */
11749
11750 static void
11751 require_complete_types_for_parms (parms)
11752      tree parms;
11753 {
11754   for (; parms; parms = TREE_CHAIN (parms))
11755     {
11756       tree type = TREE_TYPE (parms);
11757
11758       /* Try to complete the TYPE.  */
11759       type = complete_type (type);
11760
11761       if (type == error_mark_node)
11762         continue;
11763
11764       if (!COMPLETE_TYPE_P (type))
11765         {
11766           if (DECL_NAME (parms))
11767             error ("parameter `%s' has incomplete type",
11768                    IDENTIFIER_POINTER (DECL_NAME (parms)));
11769           else
11770             error ("parameter has incomplete type");
11771           TREE_TYPE (parms) = error_mark_node;
11772         }
11773       else
11774         layout_decl (parms, 0);
11775     }
11776 }
11777
11778 /* Returns non-zero if T is a local variable.  */
11779
11780 int
11781 local_variable_p (t)
11782      tree t;
11783 {
11784   if ((TREE_CODE (t) == VAR_DECL
11785        /* A VAR_DECL with a context that is a _TYPE is a static data
11786           member.  */
11787        && !TYPE_P (CP_DECL_CONTEXT (t))
11788        /* Any other non-local variable must be at namespace scope.  */
11789        && !DECL_NAMESPACE_SCOPE_P (t))
11790       || (TREE_CODE (t) == PARM_DECL))
11791     return 1;
11792
11793   return 0;
11794 }
11795
11796 /* Returns non-zero if T is an automatic local variable or a label.
11797    (These are the declarations that need to be remapped when the code
11798    containing them is duplicated.)  */
11799
11800 int
11801 nonstatic_local_decl_p (t)
11802      tree t;
11803 {
11804   return ((local_variable_p (t) && !TREE_STATIC (t))
11805           || TREE_CODE (t) == LABEL_DECL
11806           || TREE_CODE (t) == RESULT_DECL);
11807 }
11808
11809 /* Like local_variable_p, but suitable for use as a tree-walking
11810    function.  */
11811
11812 static tree
11813 local_variable_p_walkfn (tp, walk_subtrees, data)
11814      tree *tp;
11815      int *walk_subtrees ATTRIBUTE_UNUSED;
11816      void *data ATTRIBUTE_UNUSED;
11817 {
11818   return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
11819           ? *tp : NULL_TREE);
11820 }
11821
11822 /* Check that ARG, which is a default-argument expression for a
11823    parameter DECL, is legal.  Returns ARG, or ERROR_MARK_NODE, if
11824    something goes wrong.  DECL may also be a _TYPE node, rather than a
11825    DECL, if there is no DECL available.  */
11826
11827 tree
11828 check_default_argument (decl, arg)
11829      tree decl;
11830      tree arg;
11831 {
11832   tree var;
11833   tree decl_type;
11834
11835   if (TREE_CODE (arg) == DEFAULT_ARG)
11836     /* We get a DEFAULT_ARG when looking at an in-class declaration
11837        with a default argument.  Ignore the argument for now; we'll
11838        deal with it after the class is complete.  */
11839     return arg;
11840
11841   if (processing_template_decl || uses_template_parms (arg))
11842     /* We don't do anything checking until instantiation-time.  Note
11843        that there may be uninstantiated arguments even for an
11844        instantiated function, since default arguments are not
11845        instantiated until they are needed.  */
11846     return arg;
11847
11848   if (TYPE_P (decl))
11849     {
11850       decl_type = decl;
11851       decl = NULL_TREE;
11852     }
11853   else
11854     decl_type = TREE_TYPE (decl);
11855
11856   if (arg == error_mark_node
11857       || decl == error_mark_node
11858       || TREE_TYPE (arg) == error_mark_node
11859       || decl_type == error_mark_node)
11860     /* Something already went wrong.  There's no need to check
11861        further.  */
11862     return error_mark_node;
11863
11864   /* [dcl.fct.default]
11865
11866      A default argument expression is implicitly converted to the
11867      parameter type.  */
11868   if (!TREE_TYPE (arg)
11869       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
11870     {
11871       if (decl)
11872         cp_error ("default argument for `%#D' has type `%T'",
11873                   decl, TREE_TYPE (arg));
11874       else
11875         cp_error ("default argument for parameter of type `%T' has type `%T'",
11876                   decl_type, TREE_TYPE (arg));
11877
11878       return error_mark_node;
11879     }
11880
11881   /* [dcl.fct.default]
11882
11883      Local variables shall not be used in default argument
11884      expressions.
11885
11886      The keyword `this' shall not be used in a default argument of a
11887      member function.  */
11888   var = walk_tree (&arg, local_variable_p_walkfn, NULL);
11889   if (var)
11890     {
11891       cp_error ("default argument `%E' uses local variable `%D'",
11892                 arg, var);
11893       return error_mark_node;
11894     }
11895
11896   /* All is well.  */
11897   return arg;
11898 }
11899
11900 /* Decode the list of parameter types for a function type.
11901    Given the list of things declared inside the parens,
11902    return a list of types.
11903
11904    The list we receive can have three kinds of elements:
11905    an IDENTIFIER_NODE for names given without types,
11906    a TREE_LIST node for arguments given as typespecs or names with typespecs,
11907    or void_type_node, to mark the end of an argument list
11908    when additional arguments are not permitted (... was not used).
11909
11910    FUNCDEF_FLAG is nonzero for a function definition, 0 for
11911    a mere declaration.  A nonempty identifier-list gets an error message
11912    when FUNCDEF_FLAG is zero.
11913    If FUNCDEF_FLAG is 1, then parameter types must be complete.
11914    If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
11915
11916    If all elements of the input list contain types,
11917    we return a list of the types.
11918    If all elements contain no type (except perhaps a void_type_node
11919    at the end), we return a null list.
11920    If some have types and some do not, it is an error, and we
11921    return a null list.
11922
11923    Also set last_function_parms to either
11924    a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
11925    A list of names is converted to a chain of PARM_DECLs
11926    by store_parm_decls so that ultimately it is always a chain of decls.
11927
11928    Note that in C++, parameters can take default values.  These default
11929    values are in the TREE_PURPOSE field of the TREE_LIST.  It is
11930    an error to specify default values which are followed by parameters
11931    that have no default values, or an ELLIPSES.  For simplicities sake,
11932    only parameters which are specified with their types can take on
11933    default values.  */
11934
11935 static tree
11936 grokparms (first_parm, funcdef_flag)
11937      tree first_parm;
11938      int funcdef_flag;
11939 {
11940   tree result = NULL_TREE;
11941   tree decls = NULL_TREE;
11942
11943   if (first_parm != NULL_TREE
11944       && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
11945     {
11946       if (! funcdef_flag)
11947         pedwarn ("parameter names (without types) in function declaration");
11948       last_function_parms = first_parm;
11949       return NULL_TREE;
11950     }
11951   else if (first_parm != NULL_TREE
11952            && TREE_CODE (TREE_VALUE (first_parm)) != TREE_LIST
11953            && TREE_CODE (TREE_VALUE (first_parm)) != VOID_TYPE)
11954     my_friendly_abort (145);
11955   else
11956     {
11957       /* Types were specified.  This is a list of declarators
11958          each represented as a TREE_LIST node.  */
11959       register tree parm, chain;
11960       int any_init = 0, any_error = 0;
11961
11962       if (first_parm != NULL_TREE)
11963         {
11964           tree last_result = NULL_TREE;
11965           tree last_decl = NULL_TREE;
11966
11967           for (parm = first_parm; parm != NULL_TREE; parm = chain)
11968             {
11969               tree type = NULL_TREE, list_node = parm;
11970               register tree decl = TREE_VALUE (parm);
11971               tree init = TREE_PURPOSE (parm);
11972
11973               chain = TREE_CHAIN (parm);
11974               /* @@ weak defense against parse errors.  */
11975               if (TREE_CODE (decl) != VOID_TYPE
11976                   && TREE_CODE (decl) != TREE_LIST)
11977                 {
11978                   /* Give various messages as the need arises.  */
11979                   if (TREE_CODE (decl) == STRING_CST)
11980                     cp_error ("invalid string constant `%E'", decl);
11981                   else if (TREE_CODE (decl) == INTEGER_CST)
11982                     error ("invalid integer constant in parameter list, did you forget to give parameter name?");
11983                   continue;
11984                 }
11985
11986               if (TREE_CODE (decl) != VOID_TYPE)
11987                 {
11988                   decl = grokdeclarator (TREE_VALUE (decl),
11989                                          TREE_PURPOSE (decl),
11990                                          PARM, init != NULL_TREE,
11991                                          NULL_TREE);
11992                   if (! decl || TREE_TYPE (decl) == error_mark_node)
11993                     continue;
11994
11995                   /* Top-level qualifiers on the parameters are
11996                      ignored for function types.  */
11997                   type = TYPE_MAIN_VARIANT (TREE_TYPE (decl));
11998
11999                   if (TREE_CODE (type) == VOID_TYPE)
12000                     decl = void_type_node;
12001                   else if (TREE_CODE (type) == METHOD_TYPE)
12002                     {
12003                       if (DECL_NAME (decl))
12004                         /* Cannot use the decl here because
12005                            we don't have DECL_CONTEXT set up yet.  */
12006                         cp_error ("parameter `%D' invalidly declared method type",
12007                                   DECL_NAME (decl));
12008                       else
12009                         error ("parameter invalidly declared method type");
12010                       type = build_pointer_type (type);
12011                       TREE_TYPE (decl) = type;
12012                     }
12013                   else if (TREE_CODE (type) == OFFSET_TYPE)
12014                     {
12015                       if (DECL_NAME (decl))
12016                         cp_error ("parameter `%D' invalidly declared offset type",
12017                                   DECL_NAME (decl));
12018                       else
12019                         error ("parameter invalidly declared offset type");
12020                       type = build_pointer_type (type);
12021                       TREE_TYPE (decl) = type;
12022                     }
12023                   else if (abstract_virtuals_error (decl, type))
12024                     any_error = 1;  /* Seems like a good idea. */
12025                   else if (POINTER_TYPE_P (type))
12026                     {
12027                       tree t = type;
12028                       while (POINTER_TYPE_P (t)
12029                              || (TREE_CODE (t) == ARRAY_TYPE
12030                                  && TYPE_DOMAIN (t) != NULL_TREE))
12031                         t = TREE_TYPE (t);
12032                       if (TREE_CODE (t) == ARRAY_TYPE)
12033                         cp_error ("parameter type `%T' includes %s to array of unknown bound",
12034                                   type,
12035                                   TYPE_PTR_P (type) ? "pointer" : "reference");
12036                     }
12037                 }
12038
12039               if (TREE_CODE (decl) == VOID_TYPE)
12040                 {
12041                   if (result == NULL_TREE)
12042                     {
12043                       result = void_list_node;
12044                       last_result = result;
12045                     }
12046                   else
12047                     {
12048                       TREE_CHAIN (last_result) = void_list_node;
12049                       last_result = void_list_node;
12050                     }
12051                   if (chain
12052                       && (chain != void_list_node || TREE_CHAIN (chain)))
12053                     error ("`void' in parameter list must be entire list");
12054                   break;
12055                 }
12056
12057               /* Since there is a prototype, args are passed in their own types.  */
12058               DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
12059               if (PROMOTE_PROTOTYPES
12060                   && (TREE_CODE (type) == INTEGER_TYPE
12061                       || TREE_CODE (type) == ENUMERAL_TYPE)
12062                   && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
12063                 DECL_ARG_TYPE (decl) = integer_type_node;
12064               if (!any_error && init)
12065                 {
12066                   any_init++;
12067                   init = check_default_argument (decl, init);
12068                 }
12069               else
12070                 init = NULL_TREE;
12071
12072               if (decls == NULL_TREE)
12073                 {
12074                   decls = decl;
12075                   last_decl = decls;
12076                 }
12077               else
12078                 {
12079                   TREE_CHAIN (last_decl) = decl;
12080                   last_decl = decl;
12081                 }
12082               list_node = tree_cons (init, type, NULL_TREE);
12083               if (result == NULL_TREE)
12084                 {
12085                   result = list_node;
12086                   last_result = result;
12087                 }
12088               else
12089                 {
12090                   TREE_CHAIN (last_result) = list_node;
12091                   last_result = list_node;
12092                 }
12093             }
12094           if (last_result)
12095             TREE_CHAIN (last_result) = NULL_TREE;
12096           /* If there are no parameters, and the function does not end
12097              with `...', then last_decl will be NULL_TREE.  */
12098           if (last_decl != NULL_TREE)
12099             TREE_CHAIN (last_decl) = NULL_TREE;
12100         }
12101     }
12102
12103   last_function_parms = decls;
12104
12105   return result;
12106 }
12107
12108 /* Called from the parser to update an element of TYPE_ARG_TYPES for some
12109    FUNCTION_TYPE with the newly parsed version of its default argument, which
12110    was previously digested as text.  See snarf_defarg et al in lex.c.  */
12111
12112 void
12113 replace_defarg (arg, init)
12114      tree arg, init;
12115 {
12116   if (! processing_template_decl
12117       && ! can_convert_arg (TREE_VALUE (arg), TREE_TYPE (init), init))
12118     cp_pedwarn ("invalid type `%T' for default argument to `%T'",
12119                 TREE_TYPE (init), TREE_VALUE (arg));
12120   TREE_PURPOSE (arg) = init;
12121 }
12122 \f
12123 /* D is a constructor or overloaded `operator='.  Returns non-zero if
12124    D's arguments allow it to be a copy constructor, or copy assignment
12125    operator.  */
12126
12127 int
12128 copy_args_p (d)
12129      tree d;
12130 {
12131   tree t;
12132
12133   if (!DECL_FUNCTION_MEMBER_P (d))
12134     return 0;
12135
12136   t = FUNCTION_ARG_CHAIN (d);
12137   if (DECL_CONSTRUCTOR_P (d) && DECL_HAS_IN_CHARGE_PARM_P (d))
12138     t = TREE_CHAIN (t);
12139   if (t && TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
12140       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t)))
12141           == DECL_CONTEXT (d))
12142       && (TREE_CHAIN (t) == NULL_TREE
12143           || TREE_CHAIN (t) == void_list_node
12144           || TREE_PURPOSE (TREE_CHAIN (t))))
12145     return 1;
12146   return 0;
12147 }
12148
12149 /* These memoizing functions keep track of special properties which
12150    a class may have.  `grok_ctor_properties' notices whether a class
12151    has a constructor of the form X(X&), and also complains
12152    if the class has a constructor of the form X(X).
12153    `grok_op_properties' takes notice of the various forms of
12154    operator= which are defined, as well as what sorts of type conversion
12155    may apply.  Both functions take a FUNCTION_DECL as an argument.  */
12156
12157 int
12158 grok_ctor_properties (ctype, decl)
12159      tree ctype, decl;
12160 {
12161   tree parmtypes = FUNCTION_ARG_CHAIN (decl);
12162   tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
12163
12164   /* When a type has virtual baseclasses, a magical first int argument is
12165      added to any ctor so we can tell if the class has been initialized
12166      yet.  This could screw things up in this function, so we deliberately
12167      ignore the leading int if we're in that situation.  */
12168   if (DECL_HAS_IN_CHARGE_PARM_P (decl))
12169     {
12170       my_friendly_assert (parmtypes
12171                           && TREE_VALUE (parmtypes) == integer_type_node,
12172                           980529);
12173       parmtypes = TREE_CHAIN (parmtypes);
12174       parmtype = TREE_VALUE (parmtypes);
12175     }
12176
12177   /* [class.copy]
12178
12179      A non-template constructor for class X is a copy constructor if
12180      its first parameter is of type X&, const X&, volatile X& or const
12181      volatile X&, and either there are no other parameters or else all
12182      other parameters have default arguments.  */
12183   if (TREE_CODE (parmtype) == REFERENCE_TYPE
12184       && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype
12185       && (TREE_CHAIN (parmtypes) == NULL_TREE
12186           || TREE_CHAIN (parmtypes) == void_list_node
12187           || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
12188       && !(DECL_TEMPLATE_INSTANTIATION (decl)
12189            && is_member_template (DECL_TI_TEMPLATE (decl))))
12190     {
12191       TYPE_HAS_INIT_REF (ctype) = 1;
12192       if (CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12193         TYPE_HAS_CONST_INIT_REF (ctype) = 1;
12194     }
12195   /* [class.copy]
12196
12197      A declaration of a constructor for a class X is ill-formed if its
12198      first parameter is of type (optionally cv-qualified) X and either
12199      there are no other parameters or else all other parameters have
12200      default arguments.
12201
12202      We *don't* complain about member template instantiations that
12203      have this form, though; they can occur as we try to decide what
12204      constructor to use during overload resolution.  Since overload
12205      resolution will never prefer such a constructor to the
12206      non-template copy constructor (which is either explicitly or
12207      implicitly defined), there's no need to worry about their
12208      existence.  Theoretically, they should never even be
12209      instantiated, but that's hard to forestall.  */
12210   else if (TYPE_MAIN_VARIANT (parmtype) == ctype
12211            && (TREE_CHAIN (parmtypes) == NULL_TREE
12212                || TREE_CHAIN (parmtypes) == void_list_node
12213                || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
12214            && !(DECL_TEMPLATE_INSTANTIATION (decl)
12215                 && is_member_template (DECL_TI_TEMPLATE (decl))))
12216     {
12217       cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
12218                 ctype, ctype);
12219       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
12220       return 0;
12221     }
12222   else if (TREE_CODE (parmtype) == VOID_TYPE
12223            || TREE_PURPOSE (parmtypes) != NULL_TREE)
12224     TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
12225
12226   return 1;
12227 }
12228
12229 /* An operator with this code is unary, but can also be binary.  */
12230
12231 static int
12232 ambi_op_p (code)
12233      enum tree_code code;
12234 {
12235   return (code == INDIRECT_REF
12236           || code == ADDR_EXPR
12237           || code == CONVERT_EXPR
12238           || code == NEGATE_EXPR
12239           || code == PREINCREMENT_EXPR
12240           || code == PREDECREMENT_EXPR);
12241 }
12242
12243 /* An operator with this name can only be unary.  */
12244
12245 static int
12246 unary_op_p (code)
12247      enum tree_code code;
12248 {
12249   return (code == TRUTH_NOT_EXPR
12250           || code == BIT_NOT_EXPR
12251           || code == COMPONENT_REF
12252           || code == TYPE_EXPR);
12253 }
12254
12255 /* Do a little sanity-checking on how they declared their operator.  */
12256
12257 void
12258 grok_op_properties (decl, virtualp, friendp)
12259      tree decl;
12260      int virtualp, friendp;
12261 {
12262   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
12263   tree argtype;
12264   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
12265   tree name = DECL_NAME (decl);
12266   enum tree_code operator_code;
12267   int arity;
12268
12269   /* Count the number of arguments.  */
12270   for (argtype = argtypes, arity = 0;
12271        argtype && argtype != void_list_node;
12272        argtype = TREE_CHAIN (argtype))
12273     ++arity;
12274
12275   if (current_class_type == NULL_TREE)
12276     friendp = 1;
12277
12278   if (DECL_CONV_FN_P (decl))
12279     operator_code = TYPE_EXPR;
12280   else
12281     do
12282       {
12283 #define DEF_OPERATOR(NAME, CODE, NEW_MANGLING, OLD_MANGING, ARITY, ASSN_P)  \
12284         if (ansi_opname (CODE) == name)                                     \
12285           {                                                                 \
12286             operator_code = CODE;                                           \
12287             break;                                                          \
12288           }                                                                 \
12289         else if (ansi_assopname (CODE) == name)                             \
12290           {                                                                 \
12291             operator_code = CODE;                                           \
12292             DECL_ASSIGNMENT_OPERATOR_P (decl) = 1;                          \
12293             break;                                                          \
12294           }
12295
12296 #include "operators.def"
12297 #undef DEF_OPERATOR
12298
12299         my_friendly_abort (20000527);
12300       }
12301     while (0);
12302   my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526);
12303   SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12304
12305   if (! friendp)
12306     {
12307       switch (operator_code)
12308         {
12309         case CALL_EXPR:
12310           TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
12311           break;
12312
12313         case ARRAY_REF:
12314           TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
12315           break;
12316
12317         case COMPONENT_REF:
12318         case MEMBER_REF:
12319           TYPE_OVERLOADS_ARROW (current_class_type) = 1;
12320           break;
12321
12322         case NEW_EXPR:
12323           TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
12324           break;
12325
12326         case DELETE_EXPR:
12327           TYPE_GETS_DELETE (current_class_type) |= 1;
12328           break;
12329
12330         case VEC_NEW_EXPR:
12331           TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
12332           break;
12333
12334         case VEC_DELETE_EXPR:
12335           TYPE_GETS_DELETE (current_class_type) |= 2;
12336           break;
12337
12338         default:
12339           break;
12340         }
12341     }
12342
12343   if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
12344     {
12345       /* When the compiler encounters the definition of A::operator new, it
12346          doesn't look at the class declaration to find out if it's static.  */
12347       if (methodp)
12348         revert_static_member_fn (decl);
12349
12350       /* Take care of function decl if we had syntax errors.  */
12351       if (argtypes == NULL_TREE)
12352         TREE_TYPE (decl)
12353           = build_function_type (ptr_type_node,
12354                                  hash_tree_chain (integer_type_node,
12355                                                   void_list_node));
12356       else
12357         TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12358     }
12359   else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
12360     {
12361       if (methodp)
12362         revert_static_member_fn (decl);
12363
12364       if (argtypes == NULL_TREE)
12365         TREE_TYPE (decl)
12366           = build_function_type (void_type_node,
12367                                  hash_tree_chain (ptr_type_node,
12368                                                   void_list_node));
12369       else
12370         TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12371     }
12372   else
12373     {
12374       /* An operator function must either be a non-static member function
12375          or have at least one parameter of a class, a reference to a class,
12376          an enumeration, or a reference to an enumeration.  13.4.0.6 */
12377       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12378         {
12379           if (operator_code == TYPE_EXPR
12380               || operator_code == CALL_EXPR
12381               || operator_code == COMPONENT_REF
12382               || operator_code == ARRAY_REF
12383               || operator_code == NOP_EXPR)
12384             cp_error ("`%D' must be a nonstatic member function", decl);
12385           else
12386             {
12387               tree p = argtypes;
12388
12389               if (DECL_STATIC_FUNCTION_P (decl))
12390                 cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
12391
12392               if (p)
12393                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12394                   {
12395                     tree arg = TREE_VALUE (p);
12396                     if (TREE_CODE (arg) == REFERENCE_TYPE)
12397                       arg = TREE_TYPE (arg);
12398
12399                     /* This lets bad template code slip through.  */
12400                     if (IS_AGGR_TYPE (arg)
12401                         || TREE_CODE (arg) == ENUMERAL_TYPE
12402                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12403                         || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
12404                       goto foundaggr;
12405                   }
12406               cp_error
12407                 ("`%D' must have an argument of class or enumerated type",
12408                  decl);
12409             foundaggr:
12410               ;
12411             }
12412         }
12413
12414       if (operator_code == CALL_EXPR)
12415         return;                 /* No restrictions on args. */
12416
12417       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12418         {
12419           tree t = TREE_TYPE (name);
12420           if (! friendp)
12421             {
12422               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12423               const char *what = 0;
12424
12425               if (ref)
12426                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12427
12428               if (TREE_CODE (t) == VOID_TYPE)
12429                 what = "void";
12430               else if (t == current_class_type)
12431                 what = "the same type";
12432               /* Don't force t to be complete here.  */
12433               else if (IS_AGGR_TYPE (t)
12434                        && COMPLETE_TYPE_P (t)
12435                        && DERIVED_FROM_P (t, current_class_type))
12436                 what = "a base class";
12437
12438               if (what)
12439                 warning ("conversion to %s%s will never use a type conversion operator",
12440                          ref ? "a reference to " : "", what);
12441             }
12442         }
12443
12444       if (DECL_ASSIGNMENT_OPERATOR_P (decl)
12445           && operator_code == NOP_EXPR)
12446         {
12447           tree parmtype;
12448
12449           if (arity != 2 && methodp)
12450             {
12451               cp_error ("`%D' must take exactly one argument", decl);
12452               return;
12453             }
12454           parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
12455
12456           /* [class.copy]
12457
12458              A user-declared copy assignment operator X::operator= is
12459              a non-static non-template member function of class X with
12460              exactly one parameter of type X, X&, const X&, volatile
12461              X& or const volatile X&.  */
12462           if (copy_assignment_arg_p (parmtype, virtualp)
12463               && !(DECL_TEMPLATE_INSTANTIATION (decl)
12464                    && is_member_template (DECL_TI_TEMPLATE (decl)))
12465               && ! friendp)
12466             {
12467               TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
12468               if (TREE_CODE (parmtype) != REFERENCE_TYPE
12469                   || CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12470                 TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
12471             }
12472         }
12473       else if (operator_code == COND_EXPR)
12474         {
12475           /* 13.4.0.3 */
12476           cp_error ("ISO C++ prohibits overloading operator ?:");
12477         }
12478       else if (ambi_op_p (operator_code))
12479         {
12480           if (arity == 1)
12481             /* We pick the one-argument operator codes by default, so
12482                we don't have to change anything.  */
12483             ;
12484           else if (arity == 2)
12485             {
12486               /* If we thought this was a unary operator, we now know
12487                  it to be a binary operator.  */
12488               switch (operator_code)
12489                 {
12490                 case INDIRECT_REF:
12491                   operator_code = MULT_EXPR;
12492                   break;
12493
12494                 case ADDR_EXPR:
12495                   operator_code = BIT_AND_EXPR;
12496                   break;
12497
12498                 case CONVERT_EXPR:
12499                   operator_code = PLUS_EXPR;
12500                   break;
12501
12502                 case NEGATE_EXPR:
12503                   operator_code = MINUS_EXPR;
12504                   break;
12505
12506                 case PREINCREMENT_EXPR:
12507                   operator_code = POSTINCREMENT_EXPR;
12508                   break;
12509
12510                 case PREDECREMENT_EXPR:
12511                   operator_code = POSTDECREMENT_EXPR;
12512                   break;
12513
12514                 default:
12515                   my_friendly_abort (20000527);
12516                 }
12517
12518               SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12519
12520               if ((operator_code == POSTINCREMENT_EXPR
12521                    || operator_code == POSTDECREMENT_EXPR)
12522                   && ! processing_template_decl
12523                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12524                 {
12525                   if (methodp)
12526                     cp_error ("postfix `%D' must take `int' as its argument",
12527                               decl);
12528                   else
12529                     cp_error
12530                       ("postfix `%D' must take `int' as its second argument",
12531                        decl);
12532                 }
12533             }
12534           else
12535             {
12536               if (methodp)
12537                 cp_error ("`%D' must take either zero or one argument", decl);
12538               else
12539                 cp_error ("`%D' must take either one or two arguments", decl);
12540             }
12541
12542           /* More Effective C++ rule 6.  */
12543           if (warn_ecpp
12544               && (operator_code == POSTINCREMENT_EXPR
12545                   || operator_code == POSTDECREMENT_EXPR
12546                   || operator_code == PREINCREMENT_EXPR
12547                   || operator_code == PREDECREMENT_EXPR))
12548             {
12549               tree arg = TREE_VALUE (argtypes);
12550               tree ret = TREE_TYPE (TREE_TYPE (decl));
12551               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12552                 arg = TREE_TYPE (arg);
12553               arg = TYPE_MAIN_VARIANT (arg);
12554               if (operator_code == PREINCREMENT_EXPR
12555                   || operator_code == PREDECREMENT_EXPR)
12556                 {
12557                   if (TREE_CODE (ret) != REFERENCE_TYPE
12558                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12559                                        arg))
12560                     cp_warning ("prefix `%D' should return `%T'", decl,
12561                                 build_reference_type (arg));
12562                 }
12563               else
12564                 {
12565                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12566                     cp_warning ("postfix `%D' should return `%T'", decl, arg);
12567                 }
12568             }
12569         }
12570       else if (unary_op_p (operator_code))
12571         {
12572           if (arity != 1)
12573             {
12574               if (methodp)
12575                 cp_error ("`%D' must take `void'", decl);
12576               else
12577                 cp_error ("`%D' must take exactly one argument", decl);
12578             }
12579         }
12580       else /* if (binary_op_p (operator_code)) */
12581         {
12582           if (arity != 2)
12583             {
12584               if (methodp)
12585                 cp_error ("`%D' must take exactly one argument", decl);
12586               else
12587                 cp_error ("`%D' must take exactly two arguments", decl);
12588             }
12589
12590           /* More Effective C++ rule 7.  */
12591           if (warn_ecpp
12592               && (operator_code == TRUTH_ANDIF_EXPR
12593                   || operator_code == TRUTH_ORIF_EXPR
12594                   || operator_code == COMPOUND_EXPR))
12595             cp_warning ("user-defined `%D' always evaluates both arguments",
12596                         decl);
12597         }
12598
12599       /* Effective C++ rule 23.  */
12600       if (warn_ecpp
12601           && arity == 2
12602           && (operator_code == PLUS_EXPR
12603               || operator_code == MINUS_EXPR
12604               || operator_code == TRUNC_DIV_EXPR
12605               || operator_code == MULT_EXPR)
12606           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12607         cp_warning ("`%D' should return by value", decl);
12608
12609       /* 13.4.0.8 */
12610       for (; argtypes && argtypes != void_list_node;
12611           argtypes = TREE_CHAIN (argtypes))
12612         if (TREE_PURPOSE (argtypes))
12613           {
12614             TREE_PURPOSE (argtypes) = NULL_TREE;
12615             if (operator_code == POSTINCREMENT_EXPR
12616                 || operator_code == POSTDECREMENT_EXPR)
12617               {
12618                 if (pedantic)
12619                   cp_pedwarn ("`%D' cannot have default arguments", decl);
12620               }
12621             else
12622               cp_error ("`%D' cannot have default arguments", decl);
12623           }
12624
12625     }
12626 }
12627 \f
12628 static const char *
12629 tag_name (code)
12630      enum tag_types code;
12631 {
12632   switch (code)
12633     {
12634     case record_type:
12635       return "struct";
12636     case class_type:
12637       return "class";
12638     case union_type:
12639       return "union ";
12640     case enum_type:
12641       return "enum";
12642     default:
12643       my_friendly_abort (981122);
12644     }
12645 }
12646
12647 /* Get the struct, enum or union (CODE says which) with tag NAME.
12648    Define the tag as a forward-reference if it is not defined.
12649
12650    C++: If a class derivation is given, process it here, and report
12651    an error if multiple derivation declarations are not identical.
12652
12653    If this is a definition, come in through xref_tag and only look in
12654    the current frame for the name (since C++ allows new names in any
12655    scope.)  */
12656
12657 tree
12658 xref_tag (code_type_node, name, globalize)
12659      tree code_type_node;
12660      tree name;
12661      int globalize;
12662 {
12663   enum tag_types tag_code;
12664   enum tree_code code;
12665   register tree ref, t;
12666   struct binding_level *b = current_binding_level;
12667   int got_type = 0;
12668   tree attributes = NULL_TREE;
12669   tree context = NULL_TREE;
12670
12671   /* If we are called from the parser, code_type_node will sometimes be a
12672      TREE_LIST.  This indicates that the user wrote
12673      "class __attribute__ ((foo)) bar".  Extract the attributes so we can
12674      use them later.  */
12675   if (TREE_CODE (code_type_node) == TREE_LIST)
12676     {
12677       attributes = TREE_PURPOSE (code_type_node);
12678       code_type_node = TREE_VALUE (code_type_node);
12679     }
12680
12681   tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12682   switch (tag_code)
12683     {
12684     case record_type:
12685     case class_type:
12686       code = RECORD_TYPE;
12687       break;
12688     case union_type:
12689       code = UNION_TYPE;
12690       break;
12691     case enum_type:
12692       code = ENUMERAL_TYPE;
12693       break;
12694     default:
12695       my_friendly_abort (18);
12696     }
12697
12698   /* If a cross reference is requested, look up the type
12699      already defined for this tag and return it.  */
12700   if (TYPE_P (name))
12701     {
12702       t = name;
12703       name = TYPE_IDENTIFIER (t);
12704       got_type = 1;
12705     }
12706   else
12707     t = IDENTIFIER_TYPE_VALUE (name);
12708
12709   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12710       && TREE_CODE (t) != TEMPLATE_TEMPLATE_PARM)
12711     t = NULL_TREE;
12712
12713   if (! globalize)
12714     {
12715       /* If we know we are defining this tag, only look it up in
12716          this scope and don't try to find it as a type.  */
12717       ref = lookup_tag (code, name, b, 1);
12718     }
12719   else
12720     {
12721       if (t)
12722         {
12723           /* [dcl.type.elab] If the identifier resolves to a
12724              typedef-name or a template type-parameter, the
12725              elaborated-type-specifier is ill-formed.  */
12726           if (t != TYPE_MAIN_VARIANT (t)
12727               || (CLASS_TYPE_P (t) && TYPE_WAS_ANONYMOUS (t)))
12728             cp_pedwarn ("using typedef-name `%D' after `%s'",
12729                         TYPE_NAME (t), tag_name (tag_code));
12730           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12731             cp_error ("using template type parameter `%T' after `%s'",
12732                       t, tag_name (tag_code));
12733
12734           ref = t;
12735         }
12736       else
12737         ref = lookup_tag (code, name, b, 0);
12738
12739       if (! ref)
12740         {
12741           /* Try finding it as a type declaration.  If that wins,
12742              use it.  */
12743           ref = lookup_name (name, 1);
12744
12745           if (ref != NULL_TREE
12746               && processing_template_decl
12747               && DECL_CLASS_TEMPLATE_P (ref)
12748               && template_class_depth (current_class_type) == 0)
12749             /* Since GLOBALIZE is true, we're declaring a global
12750                template, so we want this type.  */
12751             ref = DECL_TEMPLATE_RESULT (ref);
12752
12753           if (ref && TREE_CODE (ref) == TYPE_DECL
12754               && TREE_CODE (TREE_TYPE (ref)) == code)
12755             ref = TREE_TYPE (ref);
12756           else
12757             ref = NULL_TREE;
12758         }
12759
12760       if (ref && current_class_type
12761           && template_class_depth (current_class_type)
12762           && PROCESSING_REAL_TEMPLATE_DECL_P ())
12763         {
12764           /* Since GLOBALIZE is non-zero, we are not looking at a
12765              definition of this tag.  Since, in addition, we are currently
12766              processing a (member) template declaration of a template
12767              class, we must be very careful; consider:
12768
12769                template <class X>
12770                struct S1
12771
12772                template <class U>
12773                struct S2
12774                { template <class V>
12775                friend struct S1; };
12776
12777              Here, the S2::S1 declaration should not be confused with the
12778              outer declaration.  In particular, the inner version should
12779              have a template parameter of level 2, not level 1.  This
12780              would be particularly important if the member declaration
12781              were instead:
12782
12783                template <class V = U> friend struct S1;
12784
12785              say, when we should tsubst into `U' when instantiating
12786              S2.  On the other hand, when presented with:
12787
12788                  template <class T>
12789                  struct S1 {
12790                    template <class U>
12791                    struct S2 {};
12792                    template <class U>
12793                    friend struct S2;
12794                  };
12795
12796               we must find the inner binding eventually.  We
12797               accomplish this by making sure that the new type we
12798               create to represent this declaration has the right
12799               TYPE_CONTEXT.  */
12800           context = TYPE_CONTEXT (ref);
12801           ref = NULL_TREE;
12802         }
12803     }
12804
12805   if (! ref)
12806     {
12807       /* If no such tag is yet defined, create a forward-reference node
12808          and record it as the "definition".
12809          When a real declaration of this type is found,
12810          the forward-reference will be altered into a real type.  */
12811       if (code == ENUMERAL_TYPE)
12812         {
12813           cp_error ("use of enum `%#D' without previous declaration", name);
12814
12815           ref = make_node (ENUMERAL_TYPE);
12816
12817           /* Give the type a default layout like unsigned int
12818              to avoid crashing if it does not get defined.  */
12819           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12820           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12821           TYPE_USER_ALIGN (ref) = 0;
12822           TREE_UNSIGNED (ref) = 1;
12823           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12824           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12825           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12826
12827           /* Enable us to recognize when a type is created in class context.
12828              To do nested classes correctly, this should probably be cleared
12829              out when we leave this classes scope.  Currently this in only
12830              done in `start_enum'.  */
12831
12832           pushtag (name, ref, globalize);
12833         }
12834       else
12835         {
12836           struct binding_level *old_b = class_binding_level;
12837
12838           ref = make_aggr_type (code);
12839           TYPE_CONTEXT (ref) = context;
12840
12841 #ifdef NONNESTED_CLASSES
12842           /* Class types don't nest the way enums do.  */
12843           class_binding_level = (struct binding_level *)0;
12844 #endif
12845           pushtag (name, ref, globalize);
12846           class_binding_level = old_b;
12847         }
12848     }
12849   else
12850     {
12851       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12852         redeclare_class_template (ref, current_template_parms);
12853     }
12854
12855   /* Until the type is defined, tentatively accept whatever
12856      structure tag the user hands us.  */
12857   if (!COMPLETE_TYPE_P (ref)
12858       && ref != current_class_type
12859       /* Have to check this, in case we have contradictory tag info.  */
12860       && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
12861     {
12862       if (tag_code == class_type)
12863         CLASSTYPE_DECLARED_CLASS (ref) = 1;
12864       else if (tag_code == record_type)
12865         CLASSTYPE_DECLARED_CLASS (ref) = 0;
12866     }
12867
12868   TREE_TYPE (ref) = attributes;
12869
12870   return ref;
12871 }
12872
12873 tree
12874 xref_tag_from_type (old, id, globalize)
12875      tree old, id;
12876      int globalize;
12877 {
12878   tree code_type_node;
12879
12880   if (TREE_CODE (old) == RECORD_TYPE)
12881     code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
12882                       ? class_type_node : record_type_node);
12883   else
12884     code_type_node = union_type_node;
12885
12886   if (id == NULL_TREE)
12887     id = TYPE_IDENTIFIER (old);
12888
12889   return xref_tag (code_type_node, id, globalize);
12890 }
12891
12892 /* REF is a type (named NAME), for which we have just seen some
12893    baseclasses.  BINFO is a list of those baseclasses; the
12894    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12895    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
12896    struct, or union.  */
12897
12898 void
12899 xref_basetypes (code_type_node, name, ref, binfo)
12900      tree code_type_node;
12901      tree name, ref;
12902      tree binfo;
12903 {
12904   /* In the declaration `A : X, Y, ... Z' we mark all the types
12905      (A, X, Y, ..., Z) so we can check for duplicates.  */
12906   tree binfos;
12907   tree base;
12908
12909   int i, len;
12910   enum tag_types tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12911
12912   if (tag_code == union_type)
12913     {
12914       cp_error ("derived union `%T' invalid", ref);
12915       return;
12916     }
12917
12918   len = list_length (binfo);
12919
12920   /* First, make sure that any templates in base-classes are
12921      instantiated.  This ensures that if we call ourselves recursively
12922      we do not get confused about which classes are marked and which
12923      are not.  */
12924   for (base = binfo; base; base = TREE_CHAIN (base))
12925     complete_type (TREE_VALUE (base));
12926
12927   SET_CLASSTYPE_MARKED (ref);
12928   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
12929
12930   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
12931     {
12932       /* The base of a derived struct is public by default.  */
12933       int via_public
12934         = (TREE_PURPOSE (binfo) == access_public_node
12935            || TREE_PURPOSE (binfo) == access_public_virtual_node
12936            || (tag_code != class_type
12937                && (TREE_PURPOSE (binfo) == access_default_node
12938                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
12939       int via_protected
12940         = (TREE_PURPOSE (binfo) == access_protected_node
12941            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
12942       int via_virtual
12943         = (TREE_PURPOSE (binfo) == access_private_virtual_node
12944            || TREE_PURPOSE (binfo) == access_protected_virtual_node
12945            || TREE_PURPOSE (binfo) == access_public_virtual_node
12946            || TREE_PURPOSE (binfo) == access_default_virtual_node);
12947       tree basetype = TREE_VALUE (binfo);
12948       tree base_binfo;
12949
12950       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
12951         basetype = TREE_TYPE (basetype);
12952       if (!basetype
12953           || (TREE_CODE (basetype) != RECORD_TYPE
12954               && TREE_CODE (basetype) != TYPENAME_TYPE
12955               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
12956               && TREE_CODE (basetype) != TEMPLATE_TEMPLATE_PARM))
12957         {
12958           cp_error ("base type `%T' fails to be a struct or class type",
12959                     TREE_VALUE (binfo));
12960           continue;
12961         }
12962
12963       GNU_xref_hier (name, basetype, via_public, via_virtual, 0);
12964
12965       /* This code replaces similar code in layout_basetypes.
12966          We put the complete_type first for implicit `typename'.  */
12967       if (!COMPLETE_TYPE_P (basetype)
12968           && ! (current_template_parms && uses_template_parms (basetype)))
12969         {
12970           cp_error ("base class `%T' has incomplete type", basetype);
12971           continue;
12972         }
12973       else
12974         {
12975           if (CLASSTYPE_MARKED (basetype))
12976             {
12977               if (basetype == ref)
12978                 cp_error ("recursive type `%T' undefined", basetype);
12979               else
12980                 cp_error ("duplicate base type `%T' invalid", basetype);
12981               continue;
12982             }
12983
12984           if (TYPE_FOR_JAVA (basetype)
12985               && (current_lang_stack
12986                   == &VARRAY_TREE (current_lang_base, 0)))
12987             TYPE_FOR_JAVA (ref) = 1;
12988
12989           /* Note that the BINFO records which describe individual
12990              inheritances are *not* shared in the lattice!  They
12991              cannot be shared because a given baseclass may be
12992              inherited with different `accessibility' by different
12993              derived classes.  (Each BINFO record describing an
12994              individual inheritance contains flags which say what
12995              the `accessibility' of that particular inheritance is.)  */
12996
12997           base_binfo
12998             = make_binfo (size_zero_node, basetype,
12999                           CLASS_TYPE_P (basetype)
13000                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
13001                           CLASS_TYPE_P (basetype)
13002                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
13003
13004           TREE_VEC_ELT (binfos, i) = base_binfo;
13005           TREE_VIA_PUBLIC (base_binfo) = via_public;
13006           TREE_VIA_PROTECTED (base_binfo) = via_protected;
13007           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
13008           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
13009
13010           /* We need to unshare the binfos now so that lookups during class
13011              definition work.  */
13012           unshare_base_binfos (base_binfo);
13013
13014           SET_CLASSTYPE_MARKED (basetype);
13015
13016           /* We are free to modify these bits because they are meaningless
13017              at top level, and BASETYPE is a top-level type.  */
13018           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
13019             {
13020               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
13021               /* Converting to a virtual base class requires looking
13022                  up the offset of the virtual base.  */
13023               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13024             }
13025
13026           if (CLASS_TYPE_P (basetype))
13027             {
13028               TYPE_HAS_NEW_OPERATOR (ref)
13029                 |= TYPE_HAS_NEW_OPERATOR (basetype);
13030               TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
13031                 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
13032               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
13033               /* If the base-class uses multiple inheritance, so do we.  */
13034               TYPE_USES_MULTIPLE_INHERITANCE (ref)
13035                 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
13036               /* Likewise, if converting to a base of the base may require
13037                  code, then we may need to generate code to convert to a
13038                  base as well.  */
13039               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
13040                 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
13041             }
13042
13043           i += 1;
13044         }
13045     }
13046   if (i)
13047     TREE_VEC_LENGTH (binfos) = i;
13048   else
13049     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
13050
13051   if (i > 1)
13052     {
13053       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
13054       /* If there is more than one non-empty they cannot be at the same
13055          address.  */
13056       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13057     }
13058
13059   /* Unmark all the types.  */
13060   while (--i >= 0)
13061     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
13062   CLEAR_CLASSTYPE_MARKED (ref);
13063
13064   /* Now that we know all the base-classes, set up the list of virtual
13065      bases.  */
13066   get_vbase_types (ref);
13067 }
13068
13069 \f
13070 /* Begin compiling the definition of an enumeration type.
13071    NAME is its name (or null if anonymous).
13072    Returns the type object, as yet incomplete.
13073    Also records info about it so that build_enumerator
13074    may be used to declare the individual values as they are read.  */
13075
13076 tree
13077 start_enum (name)
13078      tree name;
13079 {
13080   register tree enumtype = NULL_TREE;
13081   struct binding_level *b = current_binding_level;
13082
13083   /* If this is the real definition for a previous forward reference,
13084      fill in the contents in the same object that used to be the
13085      forward reference.  */
13086
13087   if (name != NULL_TREE)
13088     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
13089
13090   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
13091     {
13092       cp_error ("multiple definition of `%#T'", enumtype);
13093       cp_error_at ("previous definition here", enumtype);
13094       /* Clear out TYPE_VALUES, and start again.  */
13095       TYPE_VALUES (enumtype) = NULL_TREE;
13096     }
13097   else
13098     {
13099       enumtype = make_node (ENUMERAL_TYPE);
13100       pushtag (name, enumtype, 0);
13101     }
13102
13103   if (current_class_type)
13104     TREE_ADDRESSABLE (b->tags) = 1;
13105
13106   GNU_xref_decl (current_function_decl, enumtype);
13107   return enumtype;
13108 }
13109
13110 /* After processing and defining all the values of an enumeration type,
13111    install their decls in the enumeration type and finish it off.
13112    ENUMTYPE is the type object and VALUES a list of name-value pairs.
13113    Returns ENUMTYPE.  */
13114
13115 tree
13116 finish_enum (enumtype)
13117      tree enumtype;
13118 {
13119   register tree minnode = NULL_TREE, maxnode = NULL_TREE;
13120   /* Calculate the maximum value of any enumerator in this type.  */
13121
13122   tree values = TYPE_VALUES (enumtype);
13123   if (values)
13124     {
13125       tree pair;
13126
13127       for (pair = values; pair; pair = TREE_CHAIN (pair))
13128         {
13129           tree decl;
13130           tree value;
13131
13132           /* The TREE_VALUE is a CONST_DECL for this enumeration
13133              constant.  */
13134           decl = TREE_VALUE (pair);
13135
13136           /* [dcl.enum]
13137
13138              Following the closing brace of an enum-specifier, each
13139              enumerator has the type of its enumeration.  Prior to the
13140              closing brace, the type of each enumerator is the type of
13141              its initializing value.  */
13142           TREE_TYPE (decl) = enumtype;
13143
13144           /* The DECL_INITIAL will be NULL if we are processing a
13145              template declaration and this enumeration constant had no
13146              explicit initializer.  */
13147           value = DECL_INITIAL (decl);
13148           if (value && !processing_template_decl)
13149             {
13150               /* Set the TREE_TYPE for the VALUE as well.  That's so
13151                  that when we call decl_constant_value we get an
13152                  entity of the right type (but with the constant
13153                  value).  Since we shouldn't ever call
13154                  decl_constant_value on a template type, there's no
13155                  reason to do that when processing_template_decl.
13156                  And, if the expression is something like a
13157                  TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will
13158                  wreak havoc on the intended type of the expression.
13159
13160                  Of course, there's also no point in trying to compute
13161                  minimum or maximum values if we're in a template.  */
13162               TREE_TYPE (value) = enumtype;
13163
13164               if (!minnode)
13165                 minnode = maxnode = value;
13166               else if (tree_int_cst_lt (maxnode, value))
13167                 maxnode = value;
13168               else if (tree_int_cst_lt (value, minnode))
13169                 minnode = value;
13170             }
13171
13172           if (processing_template_decl)
13173             /* If this is just a template, leave the CONST_DECL
13174                alone.  That way tsubst_copy will find CONST_DECLs for
13175                CONST_DECLs, and not INTEGER_CSTs.  */
13176             ;
13177           else
13178             /* In the list we're building up, we want the enumeration
13179                values, not the CONST_DECLs.  */
13180             TREE_VALUE (pair) = value;
13181         }
13182     }
13183   else
13184     maxnode = minnode = integer_zero_node;
13185
13186   TYPE_VALUES (enumtype) = nreverse (values);
13187
13188   if (processing_template_decl)
13189     {
13190       tree scope = current_scope ();
13191       if (scope && TREE_CODE (scope) == FUNCTION_DECL)
13192         add_tree (build_min (TAG_DEFN, enumtype));
13193     }
13194   else
13195     {
13196       int unsignedp = tree_int_cst_sgn (minnode) >= 0;
13197       int lowprec = min_precision (minnode, unsignedp);
13198       int highprec = min_precision (maxnode, unsignedp);
13199       int precision = MAX (lowprec, highprec);
13200       tree tem;
13201
13202       TYPE_SIZE (enumtype) = NULL_TREE;
13203
13204       /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
13205
13206       TYPE_PRECISION (enumtype) = precision;
13207       if (unsignedp)
13208         fixup_unsigned_type (enumtype);
13209       else
13210         fixup_signed_type (enumtype);
13211
13212       if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
13213         /* Use the width of the narrowest normal C type which is wide
13214            enough.  */
13215         TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
13216                                                     (precision, 1));
13217       else
13218         TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
13219
13220       TYPE_SIZE (enumtype) = 0;
13221       layout_type (enumtype);
13222
13223       /* Fix up all variant types of this enum type.  */
13224       for (tem = TYPE_MAIN_VARIANT (enumtype); tem;
13225            tem = TYPE_NEXT_VARIANT (tem))
13226         {
13227           TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
13228           TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
13229           TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
13230           TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
13231           TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
13232           TYPE_MODE (tem) = TYPE_MODE (enumtype);
13233           TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
13234           TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
13235           TYPE_USER_ALIGN (tem) = TYPE_USER_ALIGN (enumtype);
13236           TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
13237         }
13238
13239       /* Finish debugging output for this type.  */
13240       rest_of_type_compilation (enumtype, namespace_bindings_p ());
13241     }
13242
13243   return enumtype;
13244 }
13245
13246 /* Build and install a CONST_DECL for an enumeration constant of the
13247    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13248    Assignment of sequential values by default is handled here.  */
13249
13250 void
13251 build_enumerator (name, value, enumtype)
13252      tree name;
13253      tree value;
13254      tree enumtype;
13255 {
13256   tree decl;
13257   tree context;
13258   tree type;
13259   tree values;
13260
13261   /* Remove no-op casts from the value.  */
13262   if (value)
13263     STRIP_TYPE_NOPS (value);
13264
13265   if (! processing_template_decl)
13266     {
13267       /* Validate and default VALUE.  */
13268       if (value != NULL_TREE)
13269         {
13270           value = decl_constant_value (value);
13271
13272           if (TREE_CODE (value) == INTEGER_CST)
13273             {
13274               value = default_conversion (value);
13275               constant_expression_warning (value);
13276             }
13277           else
13278             {
13279               cp_error ("enumerator value for `%D' not integer constant", name);
13280               value = NULL_TREE;
13281             }
13282         }
13283
13284       /* Default based on previous value.  */
13285       if (value == NULL_TREE && ! processing_template_decl)
13286         {
13287           tree prev_value;
13288
13289           if (TYPE_VALUES (enumtype))
13290             {
13291               /* The next value is the previous value ... */
13292               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
13293               /* ... plus one.  */
13294               value = cp_build_binary_op (PLUS_EXPR,
13295                                           prev_value,
13296                                           integer_one_node);
13297
13298               if (tree_int_cst_lt (value, prev_value))
13299                 cp_error ("overflow in enumeration values at `%D'", name);
13300             }
13301           else
13302             value = integer_zero_node;
13303         }
13304
13305       /* Remove no-op casts from the value.  */
13306       if (value)
13307         STRIP_TYPE_NOPS (value);
13308 #if 0
13309       /* To fix MAX_VAL enum consts. (bkoz)  */
13310       TREE_TYPE (value) = integer_type_node;
13311 #endif
13312     }
13313
13314   /* We always have to copy here; not all INTEGER_CSTs are unshared.
13315      Even in other cases, we will later (in finish_enum) be setting
13316      the type of VALUE.  But, we don't need to make a copy if this
13317      VALUE is one of the enumeration constants for this same
13318      enumeration type.  */
13319   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
13320     if (TREE_VALUE (values) == value)
13321       break;
13322   /* If we didn't break out of the loop, then we do need a copy.  */
13323   if (!values && value)
13324     value = copy_node (value);
13325
13326   /* C++ associates enums with global, function, or class declarations.  */
13327   context = current_scope ();
13328
13329   /* Build the actual enumeration constant.  Note that the enumeration
13330     constants have the type of their initializers until the
13331     enumeration is complete:
13332
13333       [ dcl.enum ]
13334
13335       Following the closing brace of an enum-specifier, each enumer-
13336       ator has the type of its enumeration.  Prior to the closing
13337       brace, the type of each enumerator is the type of its
13338       initializing value.
13339
13340     In finish_enum we will reset the type.  Of course, if we're
13341     processing a template, there may be no value.   */
13342   type = value ? TREE_TYPE (value) : NULL_TREE;
13343
13344   if (context && context == current_class_type)
13345     /* This enum declaration is local to the class.  We need the full
13346       lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
13347     decl = build_lang_decl (CONST_DECL, name, type);
13348   else
13349     /* It's a global enum, or it's local to a function.  (Note local to
13350       a function could mean local to a class method.  */
13351     decl = build_decl (CONST_DECL, name, type);
13352
13353   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
13354   DECL_INITIAL (decl) = value;
13355   TREE_READONLY (decl) = 1;
13356
13357   if (context && context == current_class_type)
13358     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13359       on the TYPE_FIELDS list for `S'.  (That's so that you can say
13360       things like `S::i' later.)  */
13361     finish_member_declaration (decl);
13362   else
13363     {
13364       pushdecl (decl);
13365       GNU_xref_decl (current_function_decl, decl);
13366     }
13367
13368   /* Add this enumeration constant to the list for this type.  */
13369   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13370 }
13371
13372 \f
13373 static int function_depth;
13374
13375 /* We're defining DECL.  Make sure that it's type is OK.  */
13376
13377 static void
13378 check_function_type (decl)
13379      tree decl;
13380 {
13381   tree fntype = TREE_TYPE (decl);
13382   tree return_type = complete_type (TREE_TYPE (fntype));
13383
13384   /* In a function definition, arg types must be complete.  */
13385   require_complete_types_for_parms (current_function_parms);
13386
13387   if (!COMPLETE_OR_VOID_TYPE_P (return_type))
13388     {
13389       cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
13390
13391       /* Make it return void instead, but don't change the
13392          type of the DECL_RESULT, in case we have a named return value.  */
13393       if (TREE_CODE (fntype) == METHOD_TYPE)
13394         {
13395           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
13396           TREE_TYPE (decl)
13397             = build_cplus_method_type (ctype,
13398                                        void_type_node,
13399                                        FUNCTION_ARG_CHAIN (decl));
13400         }
13401       else
13402         TREE_TYPE (decl)
13403           = build_function_type (void_type_node,
13404                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
13405       TREE_TYPE (decl)
13406         = build_exception_variant (fntype,
13407                                    TYPE_RAISES_EXCEPTIONS (fntype));
13408     }
13409   else
13410     abstract_virtuals_error (decl, TREE_TYPE (fntype));
13411 }
13412
13413 /* Create the FUNCTION_DECL for a function definition.
13414    DECLSPECS and DECLARATOR are the parts of the declaration;
13415    they describe the function's name and the type it returns,
13416    but twisted together in a fashion that parallels the syntax of C.
13417
13418    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13419    DECLARATOR is really the DECL for the function we are about to
13420    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13421    indicating that the function is an inline defined in-class, and
13422    SF_EXPAND indicating that we should generate RTL for this
13423    function.
13424
13425    This function creates a binding context for the function body
13426    as well as setting up the FUNCTION_DECL in current_function_decl.
13427
13428    Returns 1 on success.  If the DECLARATOR is not suitable for a function
13429    (it defines a datum instead), we return 0, which tells
13430    yyparse to report a parse error.
13431
13432    For C++, we must first check whether that datum makes any sense.
13433    For example, "class A local_a(1,2);" means that variable local_a
13434    is an aggregate of type A, which should have a constructor
13435    applied to it with the argument list [1, 2].  */
13436
13437 int
13438 start_function (declspecs, declarator, attrs, flags)
13439      tree declspecs, declarator, attrs;
13440      int flags;
13441 {
13442   tree decl1;
13443   tree ctype = NULL_TREE;
13444   tree fntype;
13445   tree restype;
13446   extern int have_extern_spec;
13447   extern int used_extern_spec;
13448   int doing_friend = 0;
13449   struct binding_level *bl;
13450
13451   /* Sanity check.  */
13452   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
13453   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
13454
13455   /* This should only be done once on the top most decl.  */
13456   if (have_extern_spec && !used_extern_spec)
13457     {
13458       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
13459       used_extern_spec = 1;
13460     }
13461
13462   if (flags & SF_PRE_PARSED)
13463     {
13464       decl1 = declarator;
13465
13466       fntype = TREE_TYPE (decl1);
13467       if (TREE_CODE (fntype) == METHOD_TYPE)
13468         ctype = TYPE_METHOD_BASETYPE (fntype);
13469
13470       /* ISO C++ 11.4/5.  A friend function defined in a class is in
13471          the (lexical) scope of the class in which it is defined.  */
13472       if (!ctype && DECL_FRIEND_P (decl1))
13473         {
13474           ctype = DECL_FRIEND_CONTEXT (decl1);
13475
13476           /* CTYPE could be null here if we're dealing with a template;
13477              for example, `inline friend float foo()' inside a template
13478              will have no CTYPE set.  */
13479           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13480             ctype = NULL_TREE;
13481           else
13482             doing_friend = 1;
13483         }
13484
13485       last_function_parms = DECL_ARGUMENTS (decl1);
13486       last_function_parm_tags = NULL_TREE;
13487     }
13488   else
13489     {
13490       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL_TREE);
13491       /* If the declarator is not suitable for a function definition,
13492          cause a syntax error.  */
13493       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
13494
13495       fntype = TREE_TYPE (decl1);
13496
13497       restype = TREE_TYPE (fntype);
13498       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13499         {
13500           cp_error ("semicolon missing after declaration of `%#T'", restype);
13501           shadow_tag (build_tree_list (NULL_TREE, restype));
13502           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13503           if (TREE_CODE (fntype) == FUNCTION_TYPE)
13504             fntype = build_function_type (integer_type_node,
13505                                           TYPE_ARG_TYPES (fntype));
13506           else
13507             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13508                                               integer_type_node,
13509                                               TYPE_ARG_TYPES (fntype));
13510           TREE_TYPE (decl1) = fntype;
13511         }
13512
13513       if (TREE_CODE (fntype) == METHOD_TYPE)
13514         ctype = TYPE_METHOD_BASETYPE (fntype);
13515       else if (DECL_MAIN_P (decl1))
13516         {
13517           /* If this doesn't return integer_type, complain.  */
13518           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13519             {
13520               if (pedantic || warn_return_type)
13521                 pedwarn ("return type for `main' changed to `int'");
13522               TREE_TYPE (decl1) = fntype = default_function_type;
13523             }
13524         }
13525     }
13526
13527   /* Sometimes we don't notice that a function is a static member, and
13528      build a METHOD_TYPE for it.  Fix that up now.  */
13529   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13530       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13531     {
13532       revert_static_member_fn (decl1);
13533       last_function_parms = TREE_CHAIN (last_function_parms);
13534       ctype = NULL_TREE;
13535     }
13536
13537   /* Warn if function was previously implicitly declared
13538      (but not if we warned then).  */
13539   if (! warn_implicit
13540       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13541     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13542
13543   /* Set up current_class_type, and enter the scope of the class, if
13544      appropriate.  */
13545   if (ctype)
13546     push_nested_class (ctype, 1);
13547   else if (DECL_STATIC_FUNCTION_P (decl1))
13548     push_nested_class (DECL_CONTEXT (decl1), 2);
13549
13550   /* Now that we have entered the scope of the class, we must restore
13551      the bindings for any template parameters surrounding DECL1, if it
13552      is an inline member template.  (Order is important; consider the
13553      case where a template parameter has the same name as a field of
13554      the class.)  It is not until after this point that
13555      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
13556   if (flags & SF_INCLASS_INLINE)
13557     maybe_begin_member_template_processing (decl1);
13558
13559   /* Effective C++ rule 15.  See also c_expand_return.  */
13560   if (warn_ecpp
13561       && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
13562       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13563     cp_warning ("`operator=' should return a reference to `*this'");
13564
13565   /* Make the init_value nonzero so pushdecl knows this is not tentative.
13566      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
13567   if (!DECL_INITIAL (decl1))
13568     DECL_INITIAL (decl1) = error_mark_node;
13569
13570 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
13571   SET_DEFAULT_DECL_ATTRIBUTES (decl1, attrs);
13572 #endif
13573
13574   /* This function exists in static storage.
13575      (This does not mean `static' in the C sense!)  */
13576   TREE_STATIC (decl1) = 1;
13577
13578   /* We must call push_template_decl after current_class_type is set
13579      up.  (If we are processing inline definitions after exiting a
13580      class scope, current_class_type will be NULL_TREE until set above
13581      by push_nested_class.)  */
13582   if (processing_template_decl)
13583     decl1 = push_template_decl (decl1);
13584
13585   /* We are now in the scope of the function being defined.  */
13586   current_function_decl = decl1;
13587
13588   /* Save the parm names or decls from this function's declarator
13589      where store_parm_decls will find them.  */
13590   current_function_parms = last_function_parms;
13591   current_function_parm_tags = last_function_parm_tags;
13592
13593   /* Make sure the parameter and return types are reasonable.  When
13594      you declare a function, these types can be incomplete, but they
13595      must be complete when you define the function.  */
13596   if (! processing_template_decl)
13597     check_function_type (decl1);
13598
13599   /* Build the return declaration for the function.  */
13600   restype = TREE_TYPE (fntype);
13601   if (!processing_template_decl)
13602     {
13603       if (!DECL_RESULT (decl1))
13604         {
13605           DECL_RESULT (decl1)
13606             = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13607           c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype),
13608                                       DECL_RESULT (decl1));
13609         }
13610     }
13611   else
13612     /* Just use `void'.  Nobody will ever look at this anyhow.  */
13613     DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, void_type_node);
13614
13615   /* Initialize RTL machinery.  We cannot do this until
13616      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
13617      even when processing a template; this is how we get
13618      CFUN set up, and our per-function variables initialized.  */
13619   bl = current_binding_level;
13620   init_function_start (decl1, input_filename, lineno);
13621   current_binding_level = bl;
13622   expanding_p = (flags & SF_EXPAND) != 0;
13623
13624   /* Even though we're inside a function body, we still don't want to
13625      call expand_expr to calculate the size of a variable-sized array.
13626      We haven't necessarily assigned RTL to all variables yet, so it's
13627      not safe to try to expand expressions involving them.  */
13628   immediate_size_expand = 0;
13629   cfun->x_dont_save_pending_sizes_p = 1;
13630
13631   /* If we're building a statement-tree, start the tree now.  */
13632   if (processing_template_decl || !expanding_p)
13633     begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13634
13635   /* Let the user know we're compiling this function.  */
13636   announce_function (decl1);
13637
13638   /* Record the decl so that the function name is defined.
13639      If we already have a decl for this name, and it is a FUNCTION_DECL,
13640      use the old decl.  */
13641   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13642     {
13643       /* A specialization is not used to guide overload resolution.  */
13644       if (!DECL_TEMPLATE_SPECIALIZATION (decl1)
13645           && ! DECL_FUNCTION_MEMBER_P (decl1))
13646         decl1 = pushdecl (decl1);
13647       else
13648         {
13649           /* We need to set the DECL_CONTEXT. */
13650           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13651             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13652           /* And make sure we have enough default args.  */
13653           check_default_args (decl1);
13654         }
13655       fntype = TREE_TYPE (decl1);
13656     }
13657
13658   /* Reset these in case the call to pushdecl changed them.  */
13659   current_function_decl = decl1;
13660   cfun->decl = decl1;
13661
13662   /* Initialize the per-function data.  */
13663   if (!DECL_PENDING_INLINE_P (decl1) && DECL_SAVED_FUNCTION_DATA (decl1))
13664     {
13665       /* If we already parsed this function, and we're just expanding it
13666          now, restore saved state.  */
13667       struct binding_level *bl = current_binding_level;
13668       *cp_function_chain = *DECL_SAVED_FUNCTION_DATA (decl1);
13669       current_binding_level = bl;
13670
13671       /* This function is being processed in whole-function mode; we
13672          already did semantic analysis.  */
13673       cfun->x_whole_function_mode_p = 1;
13674
13675       /* If we decided that we didn't want to inline this function,
13676          make sure the back-end knows that.  */
13677       if (!current_function_cannot_inline)
13678         current_function_cannot_inline = cp_function_chain->cannot_inline;
13679
13680       /* We don't need the saved data anymore.  */
13681       free (DECL_SAVED_FUNCTION_DATA (decl1));
13682       DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13683     }
13684   else if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13685     {
13686       /* We know that this was set up by `grokclassfn'.  We do not
13687          wait until `store_parm_decls', since evil parse errors may
13688          never get us to that point.  Here we keep the consistency
13689          between `current_class_type' and `current_class_ptr'.  */
13690       tree t = DECL_ARGUMENTS (decl1);
13691
13692       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13693                           162);
13694       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13695                           19990811);
13696
13697       cp_function_chain->x_current_class_ref
13698         = build_indirect_ref (t, NULL_PTR);
13699       cp_function_chain->x_current_class_ptr = t;
13700
13701       /* Constructors and destructors need to know whether they're "in
13702          charge" of initializing virtual base classes.  */
13703       if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
13704         current_in_charge_parm = TREE_CHAIN (t);
13705     }
13706
13707   if (DECL_INTERFACE_KNOWN (decl1))
13708     {
13709       tree ctx = decl_function_context (decl1);
13710
13711       if (DECL_NOT_REALLY_EXTERN (decl1))
13712         DECL_EXTERNAL (decl1) = 0;
13713
13714       if (ctx != NULL_TREE && DECL_THIS_INLINE (ctx)
13715           && TREE_PUBLIC (ctx))
13716         /* This is a function in a local class in an extern inline
13717            function.  */
13718         comdat_linkage (decl1);
13719     }
13720   /* If this function belongs to an interface, it is public.
13721      If it belongs to someone else's interface, it is also external.
13722      This only affects inlines and template instantiations.  */
13723   else if (interface_unknown == 0
13724            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13725                || flag_alt_external_templates))
13726     {
13727       if (DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1)
13728           || processing_template_decl)
13729         {
13730           DECL_EXTERNAL (decl1)
13731             = (interface_only
13732                || (DECL_THIS_INLINE (decl1) && ! flag_implement_inlines
13733                    && !DECL_VINDEX (decl1)));
13734
13735           /* For WIN32 we also want to put these in linkonce sections.  */
13736           maybe_make_one_only (decl1);
13737         }
13738       else
13739         DECL_EXTERNAL (decl1) = 0;
13740       DECL_NOT_REALLY_EXTERN (decl1) = 0;
13741       DECL_INTERFACE_KNOWN (decl1) = 1;
13742     }
13743   else if (interface_unknown && interface_only
13744            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13745                || flag_alt_external_templates))
13746     {
13747       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13748          interface, we will have interface_only set but not
13749          interface_known.  In that case, we don't want to use the normal
13750          heuristics because someone will supply a #pragma implementation
13751          elsewhere, and deducing it here would produce a conflict.  */
13752       comdat_linkage (decl1);
13753       DECL_EXTERNAL (decl1) = 0;
13754       DECL_INTERFACE_KNOWN (decl1) = 1;
13755       DECL_DEFER_OUTPUT (decl1) = 1;
13756     }
13757   else
13758     {
13759       /* This is a definition, not a reference.
13760          So clear DECL_EXTERNAL.  */
13761       DECL_EXTERNAL (decl1) = 0;
13762
13763       if ((DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1))
13764           && ! DECL_INTERFACE_KNOWN (decl1)
13765           /* Don't try to defer nested functions for now.  */
13766           && ! decl_function_context (decl1))
13767         DECL_DEFER_OUTPUT (decl1) = 1;
13768       else
13769         DECL_INTERFACE_KNOWN (decl1) = 1;
13770     }
13771
13772   if (doing_semantic_analysis_p ())
13773     {
13774       pushlevel (0);
13775       current_binding_level->parm_flag = 1;
13776     }
13777
13778   if (attrs)
13779     cplus_decl_attributes (decl1, NULL_TREE, attrs);
13780
13781   if (!building_stmt_tree ())
13782     {
13783       GNU_xref_function (decl1, current_function_parms);
13784       make_function_rtl (decl1);
13785     }
13786
13787   /* Promote the value to int before returning it.  */
13788   if (C_PROMOTING_INTEGER_TYPE_P (restype))
13789     restype = type_promotes_to (restype);
13790
13791   /* If this fcn was already referenced via a block-scope `extern' decl
13792      (or an implicit decl), propagate certain information about the usage.  */
13793   if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1)))
13794     TREE_ADDRESSABLE (decl1) = 1;
13795
13796   if (DECL_RESULT (decl1) == NULL_TREE)
13797     {
13798       DECL_RESULT (decl1)
13799         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13800       TREE_READONLY (DECL_RESULT (decl1)) = CP_TYPE_CONST_P (restype);
13801       TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = CP_TYPE_VOLATILE_P (restype);
13802     }
13803
13804   ++function_depth;
13805
13806   if (DECL_DESTRUCTOR_P (decl1))
13807     {
13808       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13809       DECL_CONTEXT (dtor_label) = current_function_decl;
13810     }
13811   /* Under the old ABI we return `this' from constructors, so we make
13812      ordinary `return' statements in constructors jump to CTOR_LABEL;
13813      from there we return `this'.  Under the new ABI, we don't bother
13814      with any of this.  By not setting CTOR_LABEL the remainder of the
13815      machinery is automatically disabled.  */
13816   else if (!flag_new_abi && DECL_CONSTRUCTOR_P (decl1))
13817     {
13818       ctor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13819       DECL_CONTEXT (ctor_label) = current_function_decl;
13820     }
13821
13822   return 1;
13823 }
13824 \f
13825 /* Called after store_parm_decls for a function-try-block.  */
13826
13827 void
13828 expand_start_early_try_stmts ()
13829 {
13830   expand_start_try_stmts ();
13831 }
13832
13833 /* Store the parameter declarations into the current function declaration.
13834    This is called after parsing the parameter declarations, before
13835    digesting the body of the function.
13836
13837    Also install to binding contour return value identifier, if any.  */
13838
13839 void
13840 store_parm_decls ()
13841 {
13842   register tree fndecl = current_function_decl;
13843   register tree parm;
13844   int parms_have_cleanups = 0;
13845   tree cleanups = NULL_TREE;
13846
13847   /* This is a list of types declared among parms in a prototype.  */
13848   tree parmtags = current_function_parm_tags;
13849
13850   /* This is a chain of any other decls that came in among the parm
13851      declarations.  If a parm is declared with  enum {foo, bar} x;
13852      then CONST_DECLs for foo and bar are put here.  */
13853   tree nonparms = NULL_TREE;
13854
13855   /* Create a binding level for the parms.  */
13856   if (!building_stmt_tree ())
13857     expand_start_bindings (2);
13858
13859   if (current_function_parms)
13860     {
13861       /* This case is when the function was defined with an ANSI prototype.
13862          The parms already have decls, so we need not do anything here
13863          except record them as in effect
13864          and complain if any redundant old-style parm decls were written.  */
13865
13866       tree specparms = current_function_parms;
13867       tree next;
13868
13869       if (doing_semantic_analysis_p ())
13870         {
13871           /* Must clear this because it might contain TYPE_DECLs declared
13872              at class level.  */
13873           storedecls (NULL_TREE);
13874
13875           /* If we're doing semantic analysis, then we'll call pushdecl
13876              for each of these.  We must do them in reverse order so that
13877              they end in the correct forward order.  */
13878           specparms = nreverse (specparms);
13879         }
13880
13881       for (parm = specparms; parm; parm = next)
13882         {
13883           next = TREE_CHAIN (parm);
13884           if (TREE_CODE (parm) == PARM_DECL)
13885             {
13886               tree type = TREE_TYPE (parm);
13887
13888               if (doing_semantic_analysis_p ())
13889                 {
13890                   tree cleanup;
13891
13892                   if (DECL_NAME (parm) == NULL_TREE
13893                       || TREE_CODE (parm) != VOID_TYPE)
13894                     pushdecl (parm);
13895                   else
13896                     cp_error ("parameter `%D' declared void", parm);
13897
13898                   cleanup = (processing_template_decl
13899                              ? NULL_TREE
13900                              : maybe_build_cleanup (parm));
13901
13902                   if (cleanup)
13903                     cleanups = tree_cons (parm, cleanup, cleanups);
13904                 }
13905               else if (type != error_mark_node
13906                        && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
13907                 parms_have_cleanups = 1;
13908             }
13909           else
13910             {
13911               /* If we find an enum constant or a type tag,
13912                  put it aside for the moment.  */
13913               TREE_CHAIN (parm) = NULL_TREE;
13914               nonparms = chainon (nonparms, parm);
13915             }
13916         }
13917
13918       if (doing_semantic_analysis_p ())
13919         {
13920           /* Get the decls in their original chain order
13921              and record in the function.  This is all and only the
13922              PARM_DECLs that were pushed into scope by the loop above.  */
13923           DECL_ARGUMENTS (fndecl) = getdecls ();
13924           storetags (chainon (parmtags, gettags ()));
13925         }
13926     }
13927   else
13928     DECL_ARGUMENTS (fndecl) = NULL_TREE;
13929
13930   /* Now store the final chain of decls for the arguments
13931      as the decl-chain of the current lexical scope.
13932      Put the enumerators in as well, at the front so that
13933      DECL_ARGUMENTS is not modified.  */
13934   if (doing_semantic_analysis_p ())
13935     storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
13936
13937   /* Initialize the RTL code for the function.  */
13938   DECL_SAVED_INSNS (fndecl) = 0;
13939   if (! building_stmt_tree ())
13940     expand_function_start (fndecl, parms_have_cleanups);
13941
13942   current_function_parms_stored = 1;
13943
13944   /* If this function is `main', emit a call to `__main'
13945      to run global initializers, etc.  */
13946   if (DECL_MAIN_P (fndecl) && !building_stmt_tree ())
13947     expand_main_function ();
13948
13949   /* Now that we have initialized the parms, we can start their
13950      cleanups.  We cannot do this before, since expand_decl_cleanup
13951      should not be called before the parm can be used.  */
13952   while (cleanups)
13953     {
13954       finish_decl_cleanup (TREE_PURPOSE (cleanups),
13955                            TREE_VALUE (cleanups));
13956       cleanups = TREE_CHAIN (cleanups);
13957     }
13958
13959   /* Create a binding contour which can be used to catch
13960      cleanup-generated temporaries.  Also, if the return value needs or
13961      has initialization, deal with that now.  */
13962   if (parms_have_cleanups)
13963     {
13964       pushlevel (0);
13965       if (!building_stmt_tree ())
13966         expand_start_bindings (2);
13967     }
13968
13969   /* Do the starting of the exception specifications, if we have any.  */
13970   if (flag_exceptions && !processing_template_decl
13971       && flag_enforce_eh_specs
13972       && building_stmt_tree ()
13973       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13974     current_eh_spec_try_block = expand_start_eh_spec ();
13975 }
13976
13977 /* Bind a name and initialization to the return value of
13978    the current function.  */
13979
13980 void
13981 store_return_init (decl)
13982      tree decl;
13983 {
13984   /* If this named return value comes in a register, put it in a
13985      pseudo-register.  */
13986   if (DECL_REGISTER (decl))
13987     {
13988       original_result_rtx = DECL_RTL (decl);
13989       /* Note that the mode of the old DECL_RTL may be wider than the
13990          mode of DECL_RESULT, depending on the calling conventions for
13991          the processor.  For example, on the Alpha, a 32-bit integer
13992          is returned in a DImode register -- the DECL_RESULT has
13993          SImode but the DECL_RTL for the DECL_RESULT has DImode.  So,
13994          here, we use the mode the back-end has already assigned for
13995          the return value.  */
13996       DECL_RTL (decl) = gen_reg_rtx (GET_MODE (original_result_rtx));
13997       if (TREE_ADDRESSABLE (decl))
13998         put_var_into_stack (decl);
13999     }
14000 }
14001
14002 \f
14003 /* We have finished doing semantic analysis on DECL, but have not yet
14004    generated RTL for its body.  Save away our current state, so that
14005    when we want to generate RTL later we know what to do.  */
14006
14007 static void
14008 save_function_data (decl)
14009      tree decl;
14010 {
14011   struct language_function *f;
14012
14013   /* Save the language-specific per-function data so that we can
14014      get it back when we really expand this function.  */
14015   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
14016                       19990908);
14017
14018   /* Make a copy.  */
14019   f = ((struct language_function *)
14020        xmalloc (sizeof (struct language_function)));
14021   bcopy ((char *) cp_function_chain, (char *) f,
14022          sizeof (struct language_function));
14023   DECL_SAVED_FUNCTION_DATA (decl) = f;
14024
14025   /* Clear out the bits we don't need.  */
14026   f->x_stmt_tree.x_last_stmt = NULL_TREE;
14027   f->x_stmt_tree.x_last_expr_type = NULL_TREE;
14028   f->x_result_rtx = NULL_RTX;
14029   f->x_named_label_uses = NULL;
14030   f->bindings = NULL;
14031
14032   /* When we get back here again, we will be expanding.  */
14033   f->x_expanding_p = 1;
14034
14035   /* If we've already decided that we cannot inline this function, we
14036      must remember that fact when we actually go to expand the
14037      function.  */
14038   f->cannot_inline = current_function_cannot_inline;
14039 }
14040
14041 /* At the end of every constructor we generate to code to return
14042    `this'.  Do that now.  */
14043
14044 static void
14045 finish_constructor_body ()
14046 {
14047   /* Any return from a constructor will end up here.  */
14048   if (ctor_label)
14049     add_tree (build_stmt (LABEL_STMT, ctor_label));
14050
14051   /* Clear CTOR_LABEL so that finish_return_stmt knows to really
14052      generate the return, rather than a goto to CTOR_LABEL.  */
14053   ctor_label = NULL_TREE;
14054   /* In check_return_expr we translate an empty return from a
14055      constructor to a return of `this'.  */
14056   finish_return_stmt (NULL_TREE);
14057   /* Mark the end of the constructor.  */
14058   add_tree (build_stmt (CTOR_STMT));
14059 }
14060
14061 /* At the end of every destructor we generate code to restore virtual
14062    function tables to the values desired by base classes and to call
14063    to base class destructors.  Do that now.  */
14064
14065 static void
14066 finish_destructor_body ()
14067 {
14068   tree compound_stmt;
14069   tree virtual_size;
14070   tree exprstmt;
14071   tree if_stmt;
14072
14073   /* Create a block to contain all the extra code.  */
14074   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
14075
14076   /* Any return from a destructor will end up here.  */
14077   add_tree (build_stmt (LABEL_STMT, dtor_label));
14078
14079   /* Generate the code to call destructor on base class.  If this
14080      destructor belongs to a class with virtual functions, then set
14081      the virtual function table pointer to represent the type of our
14082      base class.  */
14083
14084   /* This side-effect makes call to `build_delete' generate the code
14085      we have to have at the end of this destructor.  `build_delete'
14086      will set the flag again.  */
14087   TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
14088
14089   exprstmt = build_delete (current_class_type,
14090                            current_class_ref,
14091                            sfk_base_destructor,
14092                            LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
14093                            0);
14094
14095   if (exprstmt != error_mark_node
14096       && (TREE_CODE (exprstmt) != NOP_EXPR
14097           || TREE_OPERAND (exprstmt, 0) != integer_zero_node
14098           || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
14099     {
14100       if (exprstmt != void_zero_node)
14101         /* Don't call `expand_expr_stmt' if we're not going to do
14102            anything, since -Wall will give a diagnostic.  */
14103         finish_expr_stmt (exprstmt);
14104
14105       /* Run destructors for all virtual baseclasses.  */
14106       if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
14107         {
14108           tree vbases;
14109           tree if_stmt;
14110
14111           if_stmt = begin_if_stmt ();
14112           finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
14113                                       current_in_charge_parm,
14114                                       integer_two_node),
14115                                if_stmt);
14116
14117           vbases = CLASSTYPE_VBASECLASSES (current_class_type);
14118           /* The CLASSTYPE_VBASECLASSES list is in initialization
14119              order, so we have to march through it in reverse order.  */
14120           for (vbases = nreverse (copy_list (vbases));
14121                vbases;
14122                vbases = TREE_CHAIN (vbases))
14123             {
14124               tree vbase = TREE_VALUE (vbases);
14125
14126               if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (vbase)))
14127                 {
14128                   tree vb = get_vbase
14129                     (BINFO_TYPE (vbase),
14130                      TYPE_BINFO (current_class_type));
14131                   finish_expr_stmt
14132                     (build_scoped_method_call
14133                      (current_class_ref, vb, base_dtor_identifier,
14134                       NULL_TREE));
14135                 }
14136             }
14137
14138           finish_then_clause (if_stmt);
14139           finish_if_stmt ();
14140         }
14141     }
14142
14143   virtual_size = c_sizeof (current_class_type);
14144
14145   /* At the end, call delete if that's what's requested.  */
14146
14147   /* FDIS sez: At the point of definition of a virtual destructor
14148      (including an implicit definition), non-placement operator delete
14149      shall be looked up in the scope of the destructor's class and if
14150      found shall be accessible and unambiguous.
14151
14152      This is somewhat unclear, but I take it to mean that if the class
14153      only defines placement deletes we don't do anything here.  So we
14154      pass LOOKUP_SPECULATIVELY; delete_sanity will complain for us if
14155      they ever try to delete one of these.  */
14156   exprstmt = build_op_delete_call
14157     (DELETE_EXPR, current_class_ptr, virtual_size,
14158      LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
14159
14160   if_stmt = begin_if_stmt ();
14161   finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
14162                               current_in_charge_parm,
14163                               integer_one_node),
14164                        if_stmt);
14165   finish_expr_stmt (exprstmt);
14166   finish_then_clause (if_stmt);
14167   finish_if_stmt ();
14168
14169   /* Close the block we started above.  */
14170   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
14171 }
14172
14173 /* Finish up a function declaration and compile that function
14174    all the way to assembler language output.  The free the storage
14175    for the function definition.
14176
14177    FLAGS is a bitwise or of the following values:
14178      1 - CALL_POPLEVEL
14179        An extra call to poplevel (and expand_end_bindings) must be
14180        made to take care of the binding contour for the base
14181        initializers.  This is only relevant for constructors.
14182      2 - INCLASS_INLINE
14183        We just finished processing the body of an in-class inline
14184        function definition.  (This processing will have taken place
14185        after the class definition is complete.)  */
14186
14187 tree
14188 finish_function (flags)
14189      int flags;
14190 {
14191   register tree fndecl = current_function_decl;
14192   tree fntype, ctype = NULL_TREE;
14193   /* Label to use if this function is supposed to return a value.  */
14194   tree no_return_label = NULL_TREE;
14195   int call_poplevel = (flags & 1) != 0;
14196   int inclass_inline = (flags & 2) != 0;
14197   int expand_p;
14198   int nested;
14199   int current_line = lineno;
14200
14201   /* When we get some parse errors, we can end up without a
14202      current_function_decl, so cope.  */
14203   if (fndecl == NULL_TREE)
14204     return error_mark_node;
14205
14206   nested = function_depth > 1;
14207   fntype = TREE_TYPE (fndecl);
14208
14209   /*  TREE_READONLY (fndecl) = 1;
14210       This caused &foo to be of type ptr-to-const-function
14211       which then got a warning when stored in a ptr-to-function variable.  */
14212
14213   /* This happens on strange parse errors.  */
14214   if (! current_function_parms_stored)
14215     {
14216       call_poplevel = 0;
14217       store_parm_decls ();
14218     }
14219
14220   /* For a cloned function, we've already got all the code we need;
14221      there's no need to add any extra bits.  */
14222   if (building_stmt_tree () && DECL_CLONED_FUNCTION_P (fndecl))
14223     ;
14224   else if (building_stmt_tree ())
14225     {
14226       if (DECL_CONSTRUCTOR_P (fndecl))
14227         {
14228           finish_constructor_body ();
14229           if (call_poplevel)
14230             do_poplevel ();
14231         }
14232       else if (DECL_DESTRUCTOR_P (fndecl) && !processing_template_decl)
14233         finish_destructor_body ();
14234       else if (DECL_MAIN_P (fndecl))
14235         {
14236           /* Make it so that `main' always returns 0 by default.  */
14237 #ifdef VMS
14238           finish_return_stmt (integer_one_node);
14239 #else
14240           finish_return_stmt (integer_zero_node);
14241 #endif
14242         }
14243
14244       /* Finish dealing with exception specifiers.  */
14245       if (flag_exceptions && !processing_template_decl
14246           && flag_enforce_eh_specs
14247           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14248         expand_end_eh_spec (TYPE_RAISES_EXCEPTIONS
14249                             (TREE_TYPE (current_function_decl)),
14250                             current_eh_spec_try_block);
14251     }
14252   else
14253     {
14254 #if 0
14255       if (write_symbols != NO_DEBUG /*&& TREE_CODE (fntype) != METHOD_TYPE*/)
14256         {
14257           /* Keep this code around in case we later want to control debug info
14258              based on whether a type is "used".  (jason 1999-11-11) */
14259
14260           tree ttype = target_type (fntype);
14261           tree parmdecl;
14262
14263           if (IS_AGGR_TYPE (ttype))
14264             /* Let debugger know it should output info for this type.  */
14265             note_debug_info_needed (ttype);
14266
14267           for (parmdecl = DECL_ARGUMENTS (fndecl); parmdecl; parmdecl = TREE_CHAIN (parmdecl))
14268             {
14269               ttype = target_type (TREE_TYPE (parmdecl));
14270               if (IS_AGGR_TYPE (ttype))
14271                 /* Let debugger know it should output info for this type.  */
14272                 note_debug_info_needed (ttype);
14273             }
14274         }
14275 #endif
14276
14277       /* Clean house because we will need to reorder insns here.  */
14278       do_pending_stack_adjust ();
14279
14280       if (dtor_label)
14281         ;
14282       else if (DECL_CONSTRUCTOR_P (fndecl))
14283         {
14284           if (call_poplevel)
14285             do_poplevel ();
14286         }
14287       else if (return_label != NULL_RTX
14288                && flag_this_is_variable <= 0
14289                && current_function_return_value == NULL_TREE
14290                && ! DECL_NAME (DECL_RESULT (current_function_decl)))
14291         no_return_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
14292
14293       if (flag_exceptions)
14294         expand_exception_blocks ();
14295
14296       /* If this function is supposed to return a value, ensure that
14297          we do not fall into the cleanups by mistake.  The end of our
14298          function will look like this:
14299
14300          user code (may have return stmt somewhere)
14301          goto no_return_label
14302          cleanup_label:
14303          cleanups
14304          goto return_label
14305          no_return_label:
14306          NOTE_INSN_FUNCTION_END
14307          return_label:
14308          things for return
14309
14310          If the user omits a return stmt in the USER CODE section, we
14311          will have a control path which reaches NOTE_INSN_FUNCTION_END.
14312          Otherwise, we won't.  */
14313       if (no_return_label)
14314         {
14315           DECL_CONTEXT (no_return_label) = fndecl;
14316           DECL_INITIAL (no_return_label) = error_mark_node;
14317           DECL_SOURCE_FILE (no_return_label) = input_filename;
14318           DECL_SOURCE_LINE (no_return_label) = current_line;
14319           expand_goto (no_return_label);
14320         }
14321
14322       if (cleanup_label)
14323         {
14324           /* Remove the binding contour which is used
14325              to catch cleanup-generated temporaries.  */
14326           expand_end_bindings (0, 0, 0);
14327           poplevel (0, 0, 0);
14328
14329           /* Emit label at beginning of cleanup code for parameters.  */
14330           emit_label (cleanup_label);
14331         }
14332
14333       /* Get return value into register if that's where it's supposed
14334          to be.  */
14335       if (original_result_rtx)
14336         fixup_result_decl (DECL_RESULT (fndecl), original_result_rtx);
14337
14338       /* Finish building code that will trigger warnings if users forget
14339          to make their functions return values.  */
14340       if (no_return_label || cleanup_label)
14341         emit_jump (return_label);
14342       if (no_return_label)
14343         {
14344           /* We don't need to call `expand_*_return' here because we
14345              don't need any cleanups here--this path of code is only
14346              for error checking purposes.  */
14347           expand_label (no_return_label);
14348         }
14349
14350       /* We hard-wired immediate_size_expand to zero in
14351          start_function.  Expand_function_end will decrement this
14352          variable.  So, we set the variable to one here, so that after
14353          the decrement it will remain zero.  */
14354       immediate_size_expand = 1;
14355
14356       /* Generate rtl for function exit.  */
14357       expand_function_end (input_filename, current_line, 1);
14358     }
14359
14360   /* We have to save this value here in case
14361      maybe_end_member_template_processing decides to pop all the
14362      template parameters.  */
14363   expand_p = !building_stmt_tree ();
14364
14365   /* If we're saving up tree structure, tie off the function now.  */
14366   if (!expand_p)
14367     finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
14368
14369   /* This must come after expand_function_end because cleanups might
14370      have declarations (from inline functions) that need to go into
14371      this function's blocks.  */
14372   if (doing_semantic_analysis_p ())
14373     {
14374       if (current_binding_level->parm_flag != 1)
14375         my_friendly_abort (122);
14376       poplevel (1, 0, 1);
14377     }
14378
14379   /* Remember that we were in class scope.  */
14380   if (current_class_name)
14381     ctype = current_class_type;
14382
14383   /* Must mark the RESULT_DECL as being in this function.  */
14384   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
14385
14386   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14387      to the FUNCTION_DECL node itself.  */
14388   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
14389
14390   /* Save away current state, if appropriate.  */
14391   if (!expanding_p && !processing_template_decl)
14392     save_function_data (fndecl);
14393
14394   /* If this function calls `setjmp' it cannot be inlined.  When
14395      `longjmp' is called it is not guaranteed to restore the value of
14396      local variables that have been modified since the call to
14397      `setjmp'.  So, if were to inline this function into some caller
14398      `c', then when we `longjmp', we might not restore all variables
14399      in `c'.  (It might seem, at first blush, that there's no way for
14400      this function to modify local variables in `c', but their
14401      addresses may have been stored somewhere accessible to this
14402      function.)  */
14403   if (!expanding_p && !processing_template_decl && calls_setjmp_p (fndecl))
14404     DECL_UNINLINABLE (fndecl) = 1;
14405
14406   if (expand_p)
14407     {
14408       int returns_null;
14409       int returns_value;
14410
14411       /* So we can tell if jump_optimize sets it to 1.  */
14412       can_reach_end = 0;
14413
14414       /* Before we call rest_of_compilation (which will pop the
14415          CURRENT_FUNCTION), we must save these values.  */
14416       returns_null = current_function_returns_null;
14417       returns_value = current_function_returns_value;
14418
14419       /* If this is a nested function (like a template instantiation
14420          that we're compiling in the midst of compiling something
14421          else), push a new GC context.  That will keep local variables
14422          on the stack from being collected while we're doing the
14423          compilation of this function.  */
14424       if (function_depth > 1)
14425         ggc_push_context ();
14426
14427       /* Run the optimizers and output the assembler code for this
14428          function.  */
14429       rest_of_compilation (fndecl);
14430
14431       /* Undo the call to ggc_push_context above.  */
14432       if (function_depth > 1)
14433         ggc_pop_context ();
14434
14435       if (DECL_SAVED_INSNS (fndecl) && ! TREE_ASM_WRITTEN (fndecl))
14436         {
14437           /* Set DECL_EXTERNAL so that assemble_external will be called as
14438              necessary.  We'll clear it again in finish_file.  */
14439           if (! DECL_EXTERNAL (fndecl))
14440             DECL_NOT_REALLY_EXTERN (fndecl) = 1;
14441           DECL_EXTERNAL (fndecl) = 1;
14442           defer_fn (fndecl);
14443         }
14444
14445 #if 0
14446       /* Keep this code around in case we later want to control debug info
14447          based on whether a type is "used".  (jason 1999-11-11) */
14448
14449       if (ctype && TREE_ASM_WRITTEN (fndecl))
14450         note_debug_info_needed (ctype);
14451 #endif
14452
14453       if (DECL_NAME (DECL_RESULT (fndecl)))
14454         returns_value |= can_reach_end;
14455       else
14456         returns_null |= can_reach_end;
14457
14458       if (TREE_THIS_VOLATILE (fndecl) && returns_null)
14459         warning ("`noreturn' function does return");
14460       else if (returns_null
14461                && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE)
14462         {
14463           /* Always complain if there's just no return statement.  */
14464           if (!returns_value)
14465             warning ("no return statement in function returning non-void");
14466           else if (warn_return_type || pedantic)
14467             /* If this function returns non-void and control can drop through,
14468                complain.  */
14469             warning ("control reaches end of non-void function");
14470         }
14471     }
14472   else
14473     {
14474       /* Clear out memory we no longer need.  */
14475       free_after_parsing (cfun);
14476       /* Since we never call rest_of_compilation, we never clear
14477          CFUN.  Do so explicitly.  */
14478       free_after_compilation (cfun);
14479       cfun = NULL;
14480     }
14481
14482   /* If this is a in-class inline definition, we may have to pop the
14483      bindings for the template parameters that we added in
14484      maybe_begin_member_template_processing when start_function was
14485      called.  */
14486   if (inclass_inline)
14487     maybe_end_member_template_processing ();
14488
14489   /* Leave the scope of the class.  */
14490   if (ctype)
14491     pop_nested_class ();
14492
14493   --function_depth;
14494
14495   if (!DECL_SAVED_INSNS (fndecl) && !DECL_SAVED_FUNCTION_DATA (fndecl)
14496       && !(flag_inline_trees && DECL_INLINE (fndecl)))
14497     {
14498       tree t;
14499
14500       /* Stop pointing to the local nodes about to be freed.  */
14501       /* But DECL_INITIAL must remain nonzero so we know this
14502          was an actual function definition.  */
14503       DECL_INITIAL (fndecl) = error_mark_node;
14504       for (t = DECL_ARGUMENTS (fndecl); t; t = TREE_CHAIN (t))
14505         DECL_RTL (t) = DECL_INCOMING_RTL (t) = NULL_RTX;
14506     }
14507
14508   if (DECL_STATIC_CONSTRUCTOR (fndecl))
14509     static_ctors = tree_cons (NULL_TREE, fndecl, static_ctors);
14510   if (DECL_STATIC_DESTRUCTOR (fndecl))
14511     static_dtors = tree_cons (NULL_TREE, fndecl, static_dtors);
14512
14513   /* Clean up.  */
14514   if (! nested)
14515     {
14516       /* Let the error reporting routines know that we're outside a
14517          function.  For a nested function, this value is used in
14518          pop_cp_function_context and then reset via pop_function_context.  */
14519       current_function_decl = NULL_TREE;
14520       /* We don't really care about obstacks, but the middle-end
14521          sometimes cares on what obstck things are located.  */
14522       permanent_allocation (1);
14523     }
14524
14525   return fndecl;
14526 }
14527 \f
14528 /* Create the FUNCTION_DECL for a function definition.
14529    DECLSPECS and DECLARATOR are the parts of the declaration;
14530    they describe the return type and the name of the function,
14531    but twisted together in a fashion that parallels the syntax of C.
14532
14533    This function creates a binding context for the function body
14534    as well as setting up the FUNCTION_DECL in current_function_decl.
14535
14536    Returns a FUNCTION_DECL on success.
14537
14538    If the DECLARATOR is not suitable for a function (it defines a datum
14539    instead), we return 0, which tells yyparse to report a parse error.
14540
14541    May return void_type_node indicating that this method is actually
14542    a friend.  See grokfield for more details.
14543
14544    Came here with a `.pushlevel' .
14545
14546    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14547    CHANGES TO CODE IN `grokfield'.  */
14548
14549 tree
14550 start_method (declspecs, declarator, attrlist)
14551      tree declarator, declspecs, attrlist;
14552 {
14553   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14554                                 attrlist);
14555
14556   /* Something too ugly to handle.  */
14557   if (fndecl == NULL_TREE)
14558     return NULL_TREE;
14559
14560   /* Pass friends other than inline friend functions back.  */
14561   if (fndecl == void_type_node)
14562     return fndecl;
14563
14564   if (TREE_CODE (fndecl) != FUNCTION_DECL)
14565     /* Not a function, tell parser to report parse error.  */
14566     return NULL_TREE;
14567
14568   if (DECL_IN_AGGR_P (fndecl))
14569     {
14570       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14571         {
14572           if (DECL_CONTEXT (fndecl)
14573               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14574             cp_error ("`%D' is already defined in class %s", fndecl,
14575                              TYPE_NAME_STRING (DECL_CONTEXT (fndecl)));
14576         }
14577       return void_type_node;
14578     }
14579
14580   check_template_shadow (fndecl);
14581
14582   DECL_THIS_INLINE (fndecl) = 1;
14583
14584   if (flag_default_inline)
14585     DECL_INLINE (fndecl) = 1;
14586
14587   /* We process method specializations in finish_struct_1.  */
14588   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14589     fndecl = push_template_decl (fndecl);
14590
14591   if (! DECL_FRIEND_P (fndecl))
14592     {
14593       if (TREE_CHAIN (fndecl))
14594         {
14595           fndecl = copy_node (fndecl);
14596           TREE_CHAIN (fndecl) = NULL_TREE;
14597         }
14598
14599       if (DECL_CONSTRUCTOR_P (fndecl))
14600         {
14601           if (! grok_ctor_properties (current_class_type, fndecl))
14602             return void_type_node;
14603         }
14604       else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl)))
14605         grok_op_properties (fndecl, DECL_VIRTUAL_P (fndecl), 0);
14606     }
14607
14608   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14609
14610   /* Make a place for the parms */
14611   pushlevel (0);
14612   current_binding_level->parm_flag = 1;
14613
14614   DECL_IN_AGGR_P (fndecl) = 1;
14615   return fndecl;
14616 }
14617
14618 /* Go through the motions of finishing a function definition.
14619    We don't compile this method until after the whole class has
14620    been processed.
14621
14622    FINISH_METHOD must return something that looks as though it
14623    came from GROKFIELD (since we are defining a method, after all).
14624
14625    This is called after parsing the body of the function definition.
14626    STMTS is the chain of statements that makes up the function body.
14627
14628    DECL is the ..._DECL that `start_method' provided.  */
14629
14630 tree
14631 finish_method (decl)
14632      tree decl;
14633 {
14634   register tree fndecl = decl;
14635   tree old_initial;
14636
14637   register tree link;
14638
14639   if (decl == void_type_node)
14640     return decl;
14641
14642   old_initial = DECL_INITIAL (fndecl);
14643
14644   /* Undo the level for the parms (from start_method).
14645      This is like poplevel, but it causes nothing to be
14646      saved.  Saving information here confuses symbol-table
14647      output routines.  Besides, this information will
14648      be correctly output when this method is actually
14649      compiled.  */
14650
14651   /* Clear out the meanings of the local variables of this level;
14652      also record in each decl which block it belongs to.  */
14653
14654   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14655     {
14656       if (DECL_NAME (link) != NULL_TREE)
14657         pop_binding (DECL_NAME (link), link);
14658       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14659       DECL_CONTEXT (link) = NULL_TREE;
14660     }
14661
14662   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
14663                       (HOST_WIDE_INT) current_binding_level->level_chain,
14664                       current_binding_level->parm_flag,
14665                       current_binding_level->keep);
14666
14667   poplevel (0, 0, 0);
14668
14669   DECL_INITIAL (fndecl) = old_initial;
14670
14671   /* We used to check if the context of FNDECL was different from
14672      current_class_type as another way to get inside here.  This didn't work
14673      for String.cc in libg++.  */
14674   if (DECL_FRIEND_P (fndecl))
14675     {
14676       CLASSTYPE_INLINE_FRIENDS (current_class_type)
14677         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14678       decl = void_type_node;
14679     }
14680
14681   return decl;
14682 }
14683 \f
14684 /* Called when a new struct TYPE is defined.
14685    If this structure or union completes the type of any previous
14686    variable declaration, lay it out and output its rtl.  */
14687
14688 void
14689 hack_incomplete_structures (type)
14690      tree type;
14691 {
14692   tree *list;
14693   struct binding_level *level;
14694
14695   if (!type) /* Don't do this for class templates.  */
14696     return;
14697
14698   if (namespace_bindings_p ())
14699     {
14700       level = 0;
14701       list = &namespace_scope_incomplete;
14702     }
14703   else
14704     {
14705       level = innermost_nonclass_level ();
14706       list = &level->incomplete;
14707     }
14708
14709   while (1)
14710     {
14711       while (*list)
14712         {
14713           tree decl = TREE_VALUE (*list);
14714           if ((decl && TREE_TYPE (decl) == type)
14715               || (TREE_TYPE (decl)
14716                   && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14717                   && TREE_TYPE (TREE_TYPE (decl)) == type))
14718             {
14719               int toplevel = toplevel_bindings_p ();
14720               if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14721                   && TREE_TYPE (TREE_TYPE (decl)) == type)
14722                 layout_type (TREE_TYPE (decl));
14723               layout_decl (decl, 0);
14724               rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
14725               if (! toplevel)
14726                 {
14727                   tree cleanup;
14728                   expand_decl (decl);
14729                   cleanup = maybe_build_cleanup (decl);
14730                   expand_decl_init (decl);
14731                   if (! expand_decl_cleanup (decl, cleanup))
14732                     cp_error ("parser lost in parsing declaration of `%D'",
14733                               decl);
14734                 }
14735               *list = TREE_CHAIN (*list);
14736             }
14737           else
14738             list = &TREE_CHAIN (*list);
14739         }
14740
14741       /* Keep looking through artificial binding levels generated
14742          for local variables.  */
14743       if (level && level->keep == 2)
14744         {
14745           level = level->level_chain;
14746           list = &level->incomplete;
14747         }
14748       else
14749         break;
14750     }
14751 }
14752
14753 /* If DECL is of a type which needs a cleanup, build that cleanup
14754    here.  */
14755
14756 tree
14757 maybe_build_cleanup (decl)
14758      tree decl;
14759 {
14760   tree type = TREE_TYPE (decl);
14761
14762   if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14763     {
14764       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14765       tree rval;
14766
14767       if (TREE_CODE (type) == ARRAY_TYPE)
14768         rval = decl;
14769       else
14770         {
14771           mark_addressable (decl);
14772           rval = build_unary_op (ADDR_EXPR, decl, 0);
14773         }
14774
14775       /* Optimize for space over speed here.  */
14776       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14777           || flag_expensive_optimizations)
14778         flags |= LOOKUP_NONVIRTUAL;
14779
14780       rval = build_delete (TREE_TYPE (rval), rval,
14781                            sfk_complete_destructor, flags, 0);
14782
14783       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14784           && ! TYPE_HAS_DESTRUCTOR (type))
14785         rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14786                                                build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14787
14788       return rval;
14789     }
14790   return 0;
14791 }
14792 \f
14793 /* Expand a C++ expression at the statement level.
14794    This is needed to ferret out nodes which have UNKNOWN_TYPE.
14795    The C++ type checker should get all of these out when
14796    expressions are combined with other, type-providing, expressions,
14797    leaving only orphan expressions, such as:
14798
14799    &class::bar;         / / takes its address, but does nothing with it.  */
14800
14801 void
14802 cplus_expand_expr_stmt (exp)
14803      tree exp;
14804 {
14805 #if 0
14806   /* We should do this eventually, but right now this causes regex.o from
14807      libg++ to miscompile, and tString to core dump.  */
14808   exp = build1 (CLEANUP_POINT_EXPR, TREE_TYPE (exp), exp);
14809 #endif
14810
14811   /* If we don't do this, we end up down inside expand_expr
14812      trying to do TYPE_MODE on the ERROR_MARK, and really
14813      go outside the bounds of the type.  */
14814   if (exp != error_mark_node)
14815     expand_expr_stmt (exp);
14816 }
14817
14818 /* When a stmt has been parsed, this function is called.  */
14819
14820 void
14821 finish_stmt ()
14822 {
14823   /* Always assume this statement was not an expression statement.  If
14824      it actually was an expression statement, its our callers
14825      responsibility to fix this up.  */
14826   last_expr_type = NULL_TREE;
14827 }
14828
14829 /* DECL was originally constructed as a non-static member function,
14830    but turned out to be static.  Update it accordingly.  */
14831
14832 void
14833 revert_static_member_fn (decl)
14834      tree decl;
14835 {
14836   tree tmp;
14837   tree function = TREE_TYPE (decl);
14838   tree args = TYPE_ARG_TYPES (function);
14839
14840   if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args)))
14841       != TYPE_UNQUALIFIED)
14842     cp_error ("static member function `%#D' declared with type qualifiers",
14843               *decl);
14844
14845   args = TREE_CHAIN (args);
14846   tmp = build_function_type (TREE_TYPE (function), args);
14847   tmp = build_qualified_type (tmp, CP_TYPE_QUALS (function));
14848   tmp = build_exception_variant (tmp,
14849                                  TYPE_RAISES_EXCEPTIONS (function));
14850   TREE_TYPE (decl) = tmp;
14851   if (DECL_ARGUMENTS (decl))
14852     DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
14853   DECL_STATIC_FUNCTION_P (decl) = 1;
14854 }
14855
14856 /* Initialize the variables used during compilation of a C++
14857    function.  */
14858
14859 static void
14860 push_cp_function_context (f)
14861      struct function *f;
14862 {
14863   struct language_function *p
14864     = ((struct language_function *)
14865        xcalloc (1, sizeof (struct language_function)));
14866   f->language = p;
14867
14868   /* It takes an explicit call to expand_body to generate RTL for a
14869      function.  */
14870   expanding_p = 0;
14871
14872   /* Whenever we start a new function, we destroy temporaries in the
14873      usual way.  */
14874   current_stmt_tree->stmts_are_full_exprs_p = 1;
14875 }
14876
14877 /* Free the language-specific parts of F, now that we've finished
14878    compiling the function.  */
14879
14880 static void
14881 pop_cp_function_context (f)
14882      struct function *f;
14883 {
14884   if (f->language)
14885     free (f->language);
14886   f->language = 0;
14887 }
14888
14889 /* Mark P for GC.  */
14890
14891 static void
14892 mark_lang_function (p)
14893      struct language_function *p;
14894 {
14895   if (!p)
14896     return;
14897
14898   ggc_mark_tree (p->x_ctor_label);
14899   ggc_mark_tree (p->x_dtor_label);
14900   ggc_mark_tree (p->x_current_class_ptr);
14901   ggc_mark_tree (p->x_current_class_ref);
14902   ggc_mark_tree (p->x_eh_spec_try_block);
14903   ggc_mark_tree (p->x_scope_stmt_stack);
14904
14905   ggc_mark_rtx (p->x_result_rtx);
14906
14907   mark_named_label_lists (&p->x_named_labels, &p->x_named_label_uses);
14908   mark_stmt_tree (&p->x_stmt_tree);
14909   mark_binding_level (&p->bindings);
14910 }
14911
14912 /* Mark the language-specific data in F for GC.  */
14913
14914 static void
14915 mark_cp_function_context (f)
14916      struct function *f;
14917 {
14918   mark_lang_function (f->language);
14919 }
14920
14921 void
14922 lang_mark_false_label_stack (l)
14923      struct label_node *l;
14924 {
14925   /* C++ doesn't use false_label_stack.  It better be NULL.  */
14926   my_friendly_assert (l == NULL, 19990904);
14927 }
14928
14929 void
14930 lang_mark_tree (t)
14931      tree t;
14932 {
14933   enum tree_code code = TREE_CODE (t);
14934   if (code == IDENTIFIER_NODE)
14935     {
14936       struct lang_identifier *li = (struct lang_identifier *) t;
14937       struct lang_id2 *li2 = li->x;
14938       ggc_mark_tree (li->namespace_bindings);
14939       ggc_mark_tree (li->bindings);
14940       ggc_mark_tree (li->class_value);
14941       ggc_mark_tree (li->class_template_info);
14942
14943       if (li2)
14944         {
14945           ggc_mark_tree (li2->label_value);
14946           ggc_mark_tree (li2->implicit_decl);
14947           ggc_mark_tree (li2->error_locus);
14948         }
14949     }
14950   else if (code == CPLUS_BINDING)
14951     {
14952       if (BINDING_HAS_LEVEL_P (t))
14953         mark_binding_level (&BINDING_LEVEL (t));
14954       else
14955         ggc_mark_tree (BINDING_SCOPE (t));
14956       ggc_mark_tree (BINDING_VALUE (t));
14957     }
14958   else if (code == OVERLOAD)
14959     ggc_mark_tree (OVL_FUNCTION (t));
14960   else if (code == TEMPLATE_PARM_INDEX)
14961     ggc_mark_tree (TEMPLATE_PARM_DECL (t));
14962   else if (TREE_CODE_CLASS (code) == 'd')
14963     {
14964       struct lang_decl *ld = DECL_LANG_SPECIFIC (t);
14965
14966       if (ld)
14967         {
14968           ggc_mark (ld);
14969           if (!DECL_GLOBAL_CTOR_P (t)
14970               && !DECL_GLOBAL_DTOR_P (t)
14971               && !DECL_THUNK_P (t))
14972             ggc_mark_tree (ld->decl_flags.u2.access);
14973           else if (DECL_THUNK_P (t))
14974             ggc_mark_tree (ld->decl_flags.u2.vcall_offset);
14975           ggc_mark_tree (ld->decl_flags.context);
14976           if (TREE_CODE (t) != NAMESPACE_DECL)
14977             ggc_mark_tree (ld->decl_flags.u.template_info);
14978           else
14979             mark_binding_level (&NAMESPACE_LEVEL (t));
14980           if (CAN_HAVE_FULL_LANG_DECL_P (t))
14981             {
14982               ggc_mark_tree (ld->befriending_classes);
14983               ggc_mark_tree (ld->saved_tree);
14984               ggc_mark_tree (ld->cloned_function);
14985               if (!DECL_OVERLOADED_OPERATOR_P (t))
14986                 ggc_mark_tree (ld->u2.vtt_parm);
14987               if (TREE_CODE (t) == TYPE_DECL)
14988                 ggc_mark_tree (ld->u.sorted_fields);
14989               else if (TREE_CODE (t) == FUNCTION_DECL
14990                        && !DECL_PENDING_INLINE_P (t))
14991                 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t));
14992             }
14993         }
14994     }
14995   else if (TREE_CODE_CLASS (code) == 't')
14996     {
14997       struct lang_type *lt = TYPE_LANG_SPECIFIC (t);
14998
14999       if (lt && !(TREE_CODE (t) == POINTER_TYPE
15000                   && TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE))
15001         {
15002           ggc_mark (lt);
15003           ggc_mark_tree (lt->vfields);
15004           ggc_mark_tree (lt->vbases);
15005           ggc_mark_tree (lt->tags);
15006           ggc_mark_tree (lt->size);
15007           ggc_mark_tree (lt->pure_virtuals);
15008           ggc_mark_tree (lt->friend_classes);
15009           ggc_mark_tree (lt->rtti);
15010           ggc_mark_tree (lt->methods);
15011           ggc_mark_tree (lt->template_info);
15012           ggc_mark_tree (lt->befriending_classes);
15013         }
15014       else if (lt)
15015         /* In the case of pointer-to-member function types, the
15016            TYPE_LANG_SPECIFIC is really just a tree.  */
15017         ggc_mark_tree ((tree) lt);
15018     }
15019 }