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    2001  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 "output.h"
  41 #include "except.h"
  42 #include "toplev.h"
  43 #include "../hash.h"
  44 #include "ggc.h"
  45 #include "tm_p.h"
  46
  47 extern int current_class_depth;
  48
  49 extern tree global_namespace;
  50
  51 extern int (*valid_lang_attribute) PARAMS ((tree, tree, tree, tree));
  52
  53 #ifndef BOOL_TYPE_SIZE
  54 /* In the new ABI, `bool' has size and alignment `1', on all
  55    platforms.  */
  56 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
  57 #endif
  58
  59 static tree grokparms                           PARAMS ((tree));
  60 static const char *redeclaration_error_message  PARAMS ((tree, tree));
  61
  62 static void push_binding_level PARAMS ((struct binding_level *, int,
  63                                       int));
  64 static void pop_binding_level PARAMS ((void));
  65 static void suspend_binding_level PARAMS ((void));
  66 static void resume_binding_level PARAMS ((struct binding_level *));
  67 static struct binding_level *make_binding_level PARAMS ((void));
  68 static void declare_namespace_level PARAMS ((void));
  69 static int decl_jump_unsafe PARAMS ((tree));
  70 static void storedecls PARAMS ((tree));
  71 static void require_complete_types_for_parms PARAMS ((tree));
  72 static int ambi_op_p PARAMS ((enum tree_code));
  73 static int unary_op_p PARAMS ((enum tree_code));
  74 static tree store_bindings PARAMS ((tree, tree));
  75 static tree lookup_tag_reverse PARAMS ((tree, tree));
  76 static tree obscure_complex_init PARAMS ((tree, tree));
  77 static tree lookup_name_real PARAMS ((tree, int, int, int));
  78 static void push_local_name PARAMS ((tree));
  79 static void warn_extern_redeclared_static PARAMS ((tree, tree));
  80 static tree grok_reference_init PARAMS ((tree, tree, tree));
  81 static tree grokfndecl PARAMS ((tree, tree, tree, tree, int,
  82                               enum overload_flags, tree,
  83                               tree, int, int, int, int, int, int, tree));
  84 static tree grokvardecl PARAMS ((tree, tree, RID_BIT_TYPE *, int, int, tree));
  85 static tree lookup_tag PARAMS ((enum tree_code, tree,
  86                               struct binding_level *, int));
  87 static void set_identifier_type_value_with_scope
  88         PARAMS ((tree, tree, struct binding_level *));
  89 static void record_unknown_type PARAMS ((tree, const char *));
  90 static tree build_library_fn_1 PARAMS ((tree, enum tree_code, tree));
  91 static int member_function_or_else PARAMS ((tree, tree, enum overload_flags));
  92 static void bad_specifiers PARAMS ((tree, const char *, int, int, int, int,
  93                                   int));
  94 static tree maybe_process_template_type_declaration PARAMS ((tree, int, struct binding_level*));
  95 static void check_for_uninitialized_const_var PARAMS ((tree));
  96 static unsigned long typename_hash PARAMS ((hash_table_key));
  97 static bool typename_compare PARAMS ((hash_table_key, hash_table_key));
  98 static void push_binding PARAMS ((tree, tree, struct binding_level*));
  99 static int add_binding PARAMS ((tree, tree));
 100 static void pop_binding PARAMS ((tree, tree));
 101 static tree local_variable_p_walkfn PARAMS ((tree *, int *, void *));
 102 static tree find_binding PARAMS ((tree, tree));
 103 static tree select_decl PARAMS ((tree, int));
 104 static int lookup_flags PARAMS ((int, int));
 105 static tree qualify_lookup PARAMS ((tree, int));
 106 static tree record_builtin_java_type PARAMS ((const char *, int));
 107 static const char *tag_name PARAMS ((enum tag_types code));
 108 static void find_class_binding_level PARAMS ((void));
 109 static struct binding_level *innermost_nonclass_level PARAMS ((void));
 110 static void warn_about_implicit_typename_lookup PARAMS ((tree, tree));
 111 static int walk_namespaces_r PARAMS ((tree, walk_namespaces_fn, void *));
 112 static int walk_globals_r PARAMS ((tree, void *));
 113 static void add_decl_to_level PARAMS ((tree, struct binding_level *));
 114 static tree make_label_decl PARAMS ((tree, int));
 115 static void use_label PARAMS ((tree));
 116 static void check_previous_goto_1 PARAMS ((tree, struct binding_level *, tree,
 117                                            const char *, int));
 118 static void check_previous_goto PARAMS ((struct named_label_use_list *));
 119 static void check_switch_goto PARAMS ((struct binding_level *));
 120 static void check_previous_gotos PARAMS ((tree));
 121 static void pop_label PARAMS ((tree, tree));
 122 static void pop_labels PARAMS ((tree));
 123 static void maybe_deduce_size_from_array_init PARAMS ((tree, tree));
 124 static void layout_var_decl PARAMS ((tree));
 125 static void maybe_commonize_var PARAMS ((tree));
 126 static tree check_initializer PARAMS ((tree, tree));
 127 static void make_rtl_for_nonlocal_decl PARAMS ((tree, tree, const char *));
 128 static void push_cp_function_context PARAMS ((struct function *));
 129 static void pop_cp_function_context PARAMS ((struct function *));
 130 static void mark_binding_level PARAMS ((void *));
 131 static void mark_named_label_lists PARAMS ((void *, void *));
 132 static void mark_cp_function_context PARAMS ((struct function *));
 133 static void mark_saved_scope PARAMS ((void *));
 134 static void mark_lang_function PARAMS ((struct cp_language_function *));
 135 static void save_function_data PARAMS ((tree));
 136 static void check_function_type PARAMS ((tree, tree));
 137 static void destroy_local_var PARAMS ((tree));
 138 static void finish_constructor_body PARAMS ((void));
 139 static void finish_destructor_body PARAMS ((void));
 140 static tree create_array_type_for_decl PARAMS ((tree, tree, tree));
 141 static tree get_atexit_node PARAMS ((void));
 142 static tree get_dso_handle_node PARAMS ((void));
 143 static tree start_cleanup_fn PARAMS ((void));
 144 static void end_cleanup_fn PARAMS ((void));
 145 static tree cp_make_fname_decl PARAMS ((tree, const char *, int));
 146 static void initialize_predefined_identifiers PARAMS ((void));
 147 static tree check_special_function_return_type
 148   PARAMS ((special_function_kind, tree, tree));
 149 static tree push_cp_library_fn PARAMS ((enum tree_code, tree));
 150 static tree build_cp_library_fn PARAMS ((tree, enum tree_code, tree));
 151 static void store_parm_decls PARAMS ((tree));
 152 static int cp_missing_noreturn_ok_p PARAMS ((tree));
 153
 154 #if defined (DEBUG_CP_BINDING_LEVELS)
 155 static void indent PARAMS ((void));
 156 #endif
 157
 158 /* Erroneous argument lists can use this *IFF* they do not modify it.  */
 159 tree error_mark_list;
 160
 161 /* The following symbols are subsumed in the cp_global_trees array, and
 162    listed here individually for documentation purposes.
 163
 164    C++ extensions
 165         tree wchar_decl_node;
 166
 167         tree vtable_entry_type;
 168         tree delta_type_node;
 169 #if 0
 170    Old rtti stuff.
 171         tree __baselist_desc_type_node;
 172         tree __i_desc_type_node, __m_desc_type_node;
 173         tree __t_desc_array_type, __i_desc_array_type, __m_desc_array_type;
 174 #endif
 175         tree __t_desc_type_node;
 176 #if 0
 177         tree __tp_desc_type_node;
 178 #endif
 179         tree ti_desc_type_node;
 180         tree bltn_desc_type_node, ptr_desc_type_node;
 181         tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
 182         tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
 183         tree ptm_desc_type_node;
 184         tree base_desc_type_node;
 185 #if 0
 186    Not needed yet?  May be needed one day?
 187         tree __bltn_desc_array_type, __user_desc_array_type, __class_desc_array_type;
 188         tree __ptr_desc_array_type, __attr_dec_array_type, __func_desc_array_type;
 189         tree __ptmf_desc_array_type, __ptmd_desc_array_type;
 190 #endif
 191
 192         tree class_type_node, record_type_node, union_type_node, enum_type_node;
 193         tree unknown_type_node;
 194
 195    Array type `vtable_entry_type[]'
 196
 197         tree vtbl_type_node;
 198         tree vtbl_ptr_type_node;
 199
 200    Namespaces,
 201
 202         tree std_node;
 203         tree abi_node;
 204
 205    A FUNCTION_DECL which can call `abort'.  Not necessarily the
 206    one that the user will declare, but sufficient to be called
 207    by routines that want to abort the program.
 208
 209         tree abort_fndecl;
 210
 211    The FUNCTION_DECL for the default `::operator delete'.
 212
 213         tree global_delete_fndecl;
 214
 215    Used by RTTI
 216         tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
 217         tree tinfo_var_id;
 218
 219 */
 220
 221 tree cp_global_trees[CPTI_MAX];
 222
 223 /* Indicates that there is a type value in some namespace, although
 224    that is not necessarily in scope at the moment.  */
 225
 226 static tree global_type_node;
 227
 228 /* If non-zero, this is the number of times we have entered the `std'
 229    namespace when we are treating that namespace as an alias for the
 230    global namespace.  */
 231 static int in_fake_std;
 232
 233 /* Expect only namespace names now. */
 234 static int only_namespace_names;
 235
 236 /* Used only for jumps to as-yet undefined labels, since jumps to
 237    defined labels can have their validity checked immediately.  */
 238
 239 struct named_label_use_list
 240 {
 241   struct binding_level *binding_level;
 242   tree names_in_scope;
 243   tree label_decl;
 244   const char *filename_o_goto;
 245   int lineno_o_goto;
 246   struct named_label_use_list *next;
 247 };
 248
 249 #define named_label_uses cp_function_chain->x_named_label_uses
 250
 251 #define local_names cp_function_chain->x_local_names
 252
 253 /* A list of objects which have constructors or destructors
 254    which reside in the global scope.  The decl is stored in
 255    the TREE_VALUE slot and the initializer is stored
 256    in the TREE_PURPOSE slot.  */
 257 tree static_aggregates;
 258
 259 /* -- end of C++ */
 260
 261 /* A node for the integer constants 2, and 3.  */
 262
 263 tree integer_two_node, integer_three_node;
 264
 265 /* Parsing a function declarator leaves here a chain of structure
 266    and enum types declared in the parmlist.  */
 267
 268 static tree last_function_parm_tags;
 269
 270 /* Similar, for last_function_parm_tags.  */
 271 tree last_function_parms;
 272 static tree current_function_parm_tags;
 273
 274 /* A list of all LABEL_DECLs in the function that have names.  Here so
 275    we can clear out their names' definitions at the end of the
 276    function, and so we can check the validity of jumps to these labels.  */
 277
 278 struct named_label_list
 279 {
 280   struct binding_level *binding_level;
 281   tree names_in_scope;
 282   tree old_value;
 283   tree label_decl;
 284   tree bad_decls;
 285   struct named_label_list *next;
 286   unsigned int in_try_scope : 1;
 287   unsigned int in_catch_scope : 1;
 288 };
 289
 290 #define named_labels cp_function_chain->x_named_labels
 291
 292 /* Set to 0 at beginning of a function definition, and whenever
 293    a label (case or named) is defined.  Set to value of expression
 294    returned from function when that value can be transformed into
 295    a named return value.  */
 296
 297 tree current_function_return_value;
 298
 299 /* Nonzero means use the ISO C94 dialect of C.  */
 300
 301 int flag_isoc94;
 302
 303 /* Nonzero means use the ISO C99 dialect of C.  */
 304
 305 int flag_isoc99;
 306
 307 /* Nonzero means we are a hosted implementation for code shared with C.  */
 308
 309 int flag_hosted = 1;
 310
 311 /* Nonzero means add default format_arg attributes for functions not
 312    in ISO C.  */
 313
 314 int flag_noniso_default_format_attributes = 1;
 315
 316 /* Nonzero if we want to conserve space in the .o files.  We do this
 317    by putting uninitialized data and runtime initialized data into
 318    .common instead of .data at the expense of not flagging multiple
 319    definitions.  */
 320 extern int flag_conserve_space;
 321 \f
 322 /* C and C++ flags are in decl2.c.  */
 323
 324 /* Flag used when debugging spew.c */
 325
 326 extern int spew_debug;
 327
 328 /* A expression of value 0 with the same precision as a sizetype
 329    node, but signed.  */
 330 tree signed_size_zero_node;
 331
 332 /* The name of the anonymous namespace, throughout this translation
 333    unit.  */
 334 tree anonymous_namespace_name;
 335
 336 /* The number of function bodies which we are currently processing.
 337    (Zero if we are at namespace scope, one inside the body of a
 338    function, two inside the body of a function in a local class, etc.)  */
 339 int function_depth;
 340 \f
 341 /* For each binding contour we allocate a binding_level structure
 342    which records the names defined in that contour.
 343    Contours include:
 344     0) the global one
 345     1) one for each function definition,
 346        where internal declarations of the parameters appear.
 347     2) one for each compound statement,
 348        to record its declarations.
 349
 350    The current meaning of a name can be found by searching the levels
 351    from the current one out to the global one.
 352
 353    Off to the side, may be the class_binding_level.  This exists only
 354    to catch class-local declarations.  It is otherwise nonexistent.
 355
 356    Also there may be binding levels that catch cleanups that must be
 357    run when exceptions occur.  Thus, to see whether a name is bound in
 358    the current scope, it is not enough to look in the
 359    CURRENT_BINDING_LEVEL.  You should use lookup_name_current_level
 360    instead.  */
 361
 362 /* Note that the information in the `names' component of the global contour
 363    is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers.  */
 364
 365 struct binding_level
 366   {
 367     /* A chain of _DECL nodes for all variables, constants, functions,
 368        and typedef types.  These are in the reverse of the order
 369        supplied.  There may be OVERLOADs on this list, too, but they
 370        are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD.  */
 371     tree names;
 372
 373     /* A list of structure, union and enum definitions, for looking up
 374        tag names.
 375        It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
 376        or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
 377        or ENUMERAL_TYPE node.
 378
 379        C++: the TREE_VALUE nodes can be simple types for
 380        component_bindings.  */
 381     tree tags;
 382
 383     /* A list of USING_DECL nodes. */
 384     tree usings;
 385
 386     /* A list of used namespaces. PURPOSE is the namespace,
 387        VALUE the common ancestor with this binding_level's namespace. */
 388     tree using_directives;
 389
 390     /* If this binding level is the binding level for a class, then
 391        class_shadowed is a TREE_LIST.  The TREE_PURPOSE of each node
 392        is the name of an entity bound in the class.  The TREE_TYPE is
 393        the DECL bound by this name in the class.  */
 394     tree class_shadowed;
 395
 396     /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
 397        is used for all binding levels. In addition the TREE_VALUE is the
 398        IDENTIFIER_TYPE_VALUE before we entered the class.  */
 399     tree type_shadowed;
 400
 401     /* A TREE_LIST.  Each TREE_VALUE is the LABEL_DECL for a local
 402        label in this scope.  The TREE_PURPOSE is the previous value of
 403        the IDENTIFIER_LABEL VALUE.  */
 404     tree shadowed_labels;
 405
 406     /* For each level (except not the global one),
 407        a chain of BLOCK nodes for all the levels
 408        that were entered and exited one level down.  */
 409     tree blocks;
 410
 411     /* The _TYPE node for this level, if parm_flag == 2.  */
 412     tree this_class;
 413
 414     /* The binding level which this one is contained in (inherits from).  */
 415     struct binding_level *level_chain;
 416
 417     /* List of decls in `names' that have incomplete
 418        structure or union types.  */
 419     tree incomplete;
 420
 421     /* List of VAR_DECLS saved from a previous for statement.
 422        These would be dead in ISO-conforming code, but might
 423        be referenced in ARM-era code.  These are stored in a
 424        TREE_LIST; the TREE_VALUE is the actual declaration.  */
 425     tree dead_vars_from_for;
 426
 427     /* 1 for the level that holds the parameters of a function.
 428        2 for the level that holds a class declaration.  */
 429     unsigned parm_flag : 2;
 430
 431     /* 1 means make a BLOCK for this level regardless of all else.
 432        2 for temporary binding contours created by the compiler.  */
 433     unsigned keep : 2;
 434
 435     /* Nonzero if this level "doesn't exist" for tags.  */
 436     unsigned tag_transparent : 1;
 437
 438     /* Nonzero if this level can safely have additional
 439        cleanup-needing variables added to it.  */
 440     unsigned more_cleanups_ok : 1;
 441     unsigned have_cleanups : 1;
 442
 443     /* Nonzero if this scope is for storing the decls for template
 444        parameters and generic decls; these decls will be discarded and
 445        replaced with a TEMPLATE_DECL.  */
 446     unsigned template_parms_p : 1;
 447
 448     /* Nonzero if this scope corresponds to the `<>' in a
 449        `template <>' clause.  Whenever this flag is set,
 450        TEMPLATE_PARMS_P will be set as well.  */
 451     unsigned template_spec_p : 1;
 452
 453     /* This is set for a namespace binding level.  */
 454     unsigned namespace_p : 1;
 455
 456     /* True if this level is that of a for-statement where we need to
 457        worry about ambiguous (ARM or ISO) scope rules.  */
 458     unsigned is_for_scope : 1;
 459
 460     /* True if this level corresponds to a TRY block.  Currently this
 461        information is only available while building the tree structure.  */
 462     unsigned is_try_scope : 1;
 463
 464     /* True if this level corresponds to a CATCH block.  Currently this
 465        information is only available while building the tree structure.  */
 466     unsigned is_catch_scope : 1;
 467
 468     /* Three bits left for this word.  */
 469
 470 #if defined(DEBUG_CP_BINDING_LEVELS)
 471     /* Binding depth at which this level began.  */
 472     unsigned binding_depth;
 473 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 474   };
 475
 476 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
 477
 478 /* The binding level currently in effect.  */
 479
 480 #define current_binding_level                   \
 481   (cfun && cp_function_chain->bindings          \
 482    ? cp_function_chain->bindings                \
 483    : scope_chain->bindings)
 484
 485 /* The binding level of the current class, if any.  */
 486
 487 #define class_binding_level scope_chain->class_bindings
 488
 489 /* A chain of binding_level structures awaiting reuse.  */
 490
 491 static struct binding_level *free_binding_level;
 492
 493 /* The outermost binding level, for names of file scope.
 494    This is created when the compiler is started and exists
 495    through the entire run.  */
 496
 497 static struct binding_level *global_binding_level;
 498
 499 /* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
 500
 501 static int keep_next_level_flag;
 502
 503 #if defined(DEBUG_CP_BINDING_LEVELS)
 504 static int binding_depth = 0;
 505 static int is_class_level = 0;
 506
 507 static void
 508 indent ()
 509 {
 510   register unsigned i;
 511
 512   for (i = 0; i < binding_depth*2; i++)
 513     putc (' ', stderr);
 514 }
 515 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 516
 517 static tree pushdecl_with_scope PARAMS ((tree, struct binding_level *));
 518
 519 static void
 520 push_binding_level (newlevel, tag_transparent, keep)
 521      struct binding_level *newlevel;
 522      int tag_transparent, keep;
 523 {
 524   /* Add this level to the front of the chain (stack) of levels that
 525      are active.  */
 526   memset ((char*) newlevel, 0, sizeof (struct binding_level));
 527   newlevel->level_chain = current_binding_level;
 528   current_binding_level = newlevel;
 529   newlevel->tag_transparent = tag_transparent;
 530   newlevel->more_cleanups_ok = 1;
 531
 532   newlevel->keep = keep;
 533 #if defined(DEBUG_CP_BINDING_LEVELS)
 534   newlevel->binding_depth = binding_depth;
 535   indent ();
 536   fprintf (stderr, "push %s level 0x%08x line %d\n",
 537            (is_class_level) ? "class" : "block", newlevel, lineno);
 538   is_class_level = 0;
 539   binding_depth++;
 540 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 541 }
 542
 543 /* Find the innermost enclosing class scope, and reset
 544    CLASS_BINDING_LEVEL appropriately.  */
 545
 546 static void
 547 find_class_binding_level ()
 548 {
 549   struct binding_level *level = current_binding_level;
 550
 551   while (level && level->parm_flag != 2)
 552     level = level->level_chain;
 553   if (level && level->parm_flag == 2)
 554     class_binding_level = level;
 555   else
 556     class_binding_level = 0;
 557 }
 558
 559 static void
 560 pop_binding_level ()
 561 {
 562   if (global_binding_level)
 563     {
 564       /* Cannot pop a level, if there are none left to pop.  */
 565       if (current_binding_level == global_binding_level)
 566         my_friendly_abort (123);
 567     }
 568   /* Pop the current level, and free the structure for reuse.  */
 569 #if defined(DEBUG_CP_BINDING_LEVELS)
 570   binding_depth--;
 571   indent ();
 572   fprintf (stderr, "pop  %s level 0x%08x line %d\n",
 573           (is_class_level) ? "class" : "block",
 574           current_binding_level, lineno);
 575   if (is_class_level != (current_binding_level == class_binding_level))
 576     {
 577       indent ();
 578       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 579     }
 580   is_class_level = 0;
 581 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 582   {
 583     register struct binding_level *level = current_binding_level;
 584     current_binding_level = current_binding_level->level_chain;
 585     level->level_chain = free_binding_level;
 586 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
 587     if (level->binding_depth != binding_depth)
 588       abort ();
 589 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 590     free_binding_level = level;
 591     find_class_binding_level ();
 592   }
 593 }
 594
 595 static void
 596 suspend_binding_level ()
 597 {
 598   if (class_binding_level)
 599     current_binding_level = class_binding_level;
 600
 601   if (global_binding_level)
 602     {
 603       /* Cannot suspend a level, if there are none left to suspend.  */
 604       if (current_binding_level == global_binding_level)
 605         my_friendly_abort (123);
 606     }
 607   /* Suspend the current level.  */
 608 #if defined(DEBUG_CP_BINDING_LEVELS)
 609   binding_depth--;
 610   indent ();
 611   fprintf (stderr, "suspend  %s level 0x%08x line %d\n",
 612           (is_class_level) ? "class" : "block",
 613           current_binding_level, lineno);
 614   if (is_class_level != (current_binding_level == class_binding_level))
 615     {
 616       indent ();
 617       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 618     }
 619   is_class_level = 0;
 620 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 621   current_binding_level = current_binding_level->level_chain;
 622   find_class_binding_level ();
 623 }
 624
 625 static void
 626 resume_binding_level (b)
 627      struct binding_level *b;
 628 {
 629   /* Resuming binding levels is meant only for namespaces,
 630      and those cannot nest into classes. */
 631   my_friendly_assert(!class_binding_level, 386);
 632   /* Also, resuming a non-directly nested namespace is a no-no.  */
 633   my_friendly_assert(b->level_chain == current_binding_level, 386);
 634   current_binding_level = b;
 635 #if defined(DEBUG_CP_BINDING_LEVELS)
 636   b->binding_depth = binding_depth;
 637   indent ();
 638   fprintf (stderr, "resume %s level 0x%08x line %d\n",
 639            (is_class_level) ? "class" : "block", b, lineno);
 640   is_class_level = 0;
 641   binding_depth++;
 642 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 643 }
 644 \f
 645 /* Create a new `struct binding_level'.  */
 646
 647 static
 648 struct binding_level *
 649 make_binding_level ()
 650 {
 651   /* NOSTRICT */
 652   return (struct binding_level *) xmalloc (sizeof (struct binding_level));
 653 }
 654
 655 /* Nonzero if we are currently in the global binding level.  */
 656
 657 int
 658 global_bindings_p ()
 659 {
 660   return current_binding_level == global_binding_level;
 661 }
 662
 663 /* Return the innermost binding level that is not for a class scope.  */
 664
 665 static struct binding_level *
 666 innermost_nonclass_level ()
 667 {
 668   struct binding_level *b;
 669
 670   b = current_binding_level;
 671   while (b->parm_flag == 2)
 672     b = b->level_chain;
 673
 674   return b;
 675 }
 676
 677 /* Nonzero if we are currently in a toplevel binding level.  This
 678    means either the global binding level or a namespace in a toplevel
 679    binding level.  Since there are no non-toplevel namespace levels,
 680    this really means any namespace or template parameter level.  We
 681    also include a class whose context is toplevel.  */
 682
 683 int
 684 toplevel_bindings_p ()
 685 {
 686   struct binding_level *b = innermost_nonclass_level ();
 687
 688   return b->namespace_p || b->template_parms_p;
 689 }
 690
 691 /* Nonzero if this is a namespace scope, or if we are defining a class
 692    which is itself at namespace scope, or whose enclosing class is
 693    such a class, etc.  */
 694
 695 int
 696 namespace_bindings_p ()
 697 {
 698   struct binding_level *b = innermost_nonclass_level ();
 699
 700   return b->namespace_p;
 701 }
 702
 703 /* If KEEP is non-zero, make a BLOCK node for the next binding level,
 704    unconditionally.  Otherwise, use the normal logic to decide whether
 705    or not to create a BLOCK.  */
 706
 707 void
 708 keep_next_level (keep)
 709      int keep;
 710 {
 711   keep_next_level_flag = keep;
 712 }
 713
 714 /* Nonzero if the current level needs to have a BLOCK made.  */
 715
 716 int
 717 kept_level_p ()
 718 {
 719   return (current_binding_level->blocks != NULL_TREE
 720           || current_binding_level->keep
 721           || current_binding_level->names != NULL_TREE
 722           || (current_binding_level->tags != NULL_TREE
 723               && !current_binding_level->tag_transparent));
 724 }
 725
 726 static void
 727 declare_namespace_level ()
 728 {
 729   current_binding_level->namespace_p = 1;
 730 }
 731
 732 /* Returns non-zero if this scope was created to store template
 733    parameters.  */
 734
 735 int
 736 template_parm_scope_p ()
 737 {
 738   return current_binding_level->template_parms_p;
 739 }
 740
 741 /* Returns the kind of template specialization we are currently
 742    processing, given that it's declaration contained N_CLASS_SCOPES
 743    explicit scope qualifications.  */
 744
 745 tmpl_spec_kind
 746 current_tmpl_spec_kind (n_class_scopes)
 747      int n_class_scopes;
 748 {
 749   int n_template_parm_scopes = 0;
 750   int seen_specialization_p = 0;
 751   int innermost_specialization_p = 0;
 752   struct binding_level *b;
 753
 754   /* Scan through the template parameter scopes.  */
 755   for (b = current_binding_level; b->template_parms_p; b = b->level_chain)
 756     {
 757       /* If we see a specialization scope inside a parameter scope,
 758          then something is wrong.  That corresponds to a declaration
 759          like:
 760
 761             template <class T> template <> ...
 762
 763          which is always illegal since [temp.expl.spec] forbids the
 764          specialization of a class member template if the enclosing
 765          class templates are not explicitly specialized as well.  */
 766       if (b->template_spec_p)
 767         {
 768           if (n_template_parm_scopes == 0)
 769             innermost_specialization_p = 1;
 770           else
 771             seen_specialization_p = 1;
 772         }
 773       else if (seen_specialization_p == 1)
 774         return tsk_invalid_member_spec;
 775
 776       ++n_template_parm_scopes;
 777     }
 778
 779   /* Handle explicit instantiations.  */
 780   if (processing_explicit_instantiation)
 781     {
 782       if (n_template_parm_scopes != 0)
 783         /* We've seen a template parameter list during an explicit
 784            instantiation.  For example:
 785
 786              template <class T> template void f(int);
 787
 788            This is erroneous.  */
 789         return tsk_invalid_expl_inst;
 790       else
 791         return tsk_expl_inst;
 792     }
 793
 794   if (n_template_parm_scopes < n_class_scopes)
 795     /* We've not seen enough template headers to match all the
 796        specialized classes present.  For example:
 797
 798          template <class T> void R<T>::S<T>::f(int);
 799
 800        This is illegal; there needs to be one set of template
 801        parameters for each class.  */
 802     return tsk_insufficient_parms;
 803   else if (n_template_parm_scopes == n_class_scopes)
 804     /* We're processing a non-template declaration (even though it may
 805        be a member of a template class.)  For example:
 806
 807          template <class T> void S<T>::f(int);
 808
 809        The `class T' maches the `S<T>', leaving no template headers
 810        corresponding to the `f'.  */
 811     return tsk_none;
 812   else if (n_template_parm_scopes > n_class_scopes + 1)
 813     /* We've got too many template headers.  For example:
 814
 815          template <> template <class T> void f (T);
 816
 817        There need to be more enclosing classes.  */
 818     return tsk_excessive_parms;
 819   else
 820     /* This must be a template.  It's of the form:
 821
 822          template <class T> template <class U> void S<T>::f(U);
 823
 824        This is a specialization if the innermost level was a
 825        specialization; otherwise it's just a definition of the
 826        template.  */
 827     return innermost_specialization_p ? tsk_expl_spec : tsk_template;
 828 }
 829
 830 void
 831 set_class_shadows (shadows)
 832      tree shadows;
 833 {
 834   class_binding_level->class_shadowed = shadows;
 835 }
 836
 837 /* Enter a new binding level.
 838    If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
 839    not for that of tags.  */
 840
 841 void
 842 pushlevel (tag_transparent)
 843      int tag_transparent;
 844 {
 845   struct binding_level *newlevel;
 846
 847   if (cfun && !doing_semantic_analysis_p ())
 848     return;
 849
 850   /* Reuse or create a struct for this binding level.  */
 851 #if defined(DEBUG_CP_BINDING_LEVELS)
 852   if (0)
 853 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
 854   if (free_binding_level)
 855 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
 856     {
 857       newlevel = free_binding_level;
 858       free_binding_level = free_binding_level->level_chain;
 859     }
 860   else
 861     newlevel = make_binding_level ();
 862
 863   push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
 864   GNU_xref_start_scope ((HOST_WIDE_INT) newlevel);
 865   keep_next_level_flag = 0;
 866 }
 867
 868 /* We're defining an object of type TYPE.  If it needs a cleanup, but
 869    we're not allowed to add any more objects with cleanups to the current
 870    scope, create a new binding level.  */
 871
 872 void
 873 maybe_push_cleanup_level (type)
 874      tree type;
 875 {
 876   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
 877       && current_binding_level->more_cleanups_ok == 0)
 878     {
 879       keep_next_level (2);
 880       pushlevel (1);
 881       clear_last_expr ();
 882       add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
 883     }
 884 }
 885
 886 /* Enter a new scope.  The KIND indicates what kind of scope is being
 887    created.  */
 888
 889 void
 890 begin_scope (sk)
 891      scope_kind sk;
 892 {
 893   pushlevel (0);
 894
 895   switch (sk)
 896     {
 897     case sk_template_spec:
 898       current_binding_level->template_spec_p = 1;
 899       /* Fall through.  */
 900
 901     case sk_template_parms:
 902       current_binding_level->template_parms_p = 1;
 903       break;
 904
 905     default:
 906       my_friendly_abort (20000309);
 907     }
 908 }
 909
 910 /* Exit the current scope.  */
 911
 912 void
 913 finish_scope ()
 914 {
 915   poplevel (0, 0, 0);
 916 }
 917
 918 void
 919 note_level_for_for ()
 920 {
 921   current_binding_level->is_for_scope = 1;
 922 }
 923
 924 /* Record that the current binding level represents a try block.  */
 925
 926 void
 927 note_level_for_try ()
 928 {
 929   current_binding_level->is_try_scope = 1;
 930 }
 931
 932 /* Record that the current binding level represents a catch block.  */
 933
 934 void
 935 note_level_for_catch ()
 936 {
 937   current_binding_level->is_catch_scope = 1;
 938 }
 939
 940 /* For a binding between a name and an entity at a block scope,
 941    this is the `struct binding_level' for the block.  */
 942 #define BINDING_LEVEL(NODE) \
 943    (((struct tree_binding*)NODE)->scope.level)
 944
 945 /* A free list of CPLUS_BINDING nodes, connected by their
 946    TREE_CHAINs.  */
 947
 948 static tree free_bindings;
 949
 950 /* Make DECL the innermost binding for ID.  The LEVEL is the binding
 951    level at which this declaration is being bound.  */
 952
 953 static void
 954 push_binding (id, decl, level)
 955      tree id;
 956      tree decl;
 957      struct binding_level* level;
 958 {
 959   tree binding;
 960
 961   if (free_bindings)
 962     {
 963       binding = free_bindings;
 964       free_bindings = TREE_CHAIN (binding);
 965     }
 966   else
 967     binding = make_node (CPLUS_BINDING);
 968
 969   /* Now, fill in the binding information.  */
 970   BINDING_VALUE (binding) = decl;
 971   BINDING_TYPE (binding) = NULL_TREE;
 972   BINDING_LEVEL (binding) = level;
 973   INHERITED_VALUE_BINDING_P (binding) = 0;
 974   LOCAL_BINDING_P (binding) = (level != class_binding_level);
 975   BINDING_HAS_LEVEL_P (binding) = 1;
 976
 977   /* And put it on the front of the list of bindings for ID.  */
 978   TREE_CHAIN (binding) = IDENTIFIER_BINDING (id);
 979   IDENTIFIER_BINDING (id) = binding;
 980 }
 981
 982 /* ID is already bound in the current scope.  But, DECL is an
 983    additional binding for ID in the same scope.  This is the `struct
 984    stat' hack whereby a non-typedef class-name or enum-name can be
 985    bound at the same level as some other kind of entity.  It's the
 986    responsibility of the caller to check that inserting this name is
 987    legal here.  Returns nonzero if the new binding was successful.  */
 988 static int
 989 add_binding (id, decl)
 990      tree id;
 991      tree decl;
 992 {
 993   tree binding = IDENTIFIER_BINDING (id);
 994   int ok = 1;
 995
 996   if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
 997     /* The new name is the type name.  */
 998     BINDING_TYPE (binding) = decl;
 999   else if (!BINDING_VALUE (binding))
1000     /* This situation arises when push_class_level_binding moves an
1001        inherited type-binding out of the way to make room for a new
1002        value binding.  */
1003     BINDING_VALUE (binding) = decl;
1004   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
1005            && DECL_ARTIFICIAL (BINDING_VALUE (binding)))
1006     {
1007       /* The old binding was a type name.  It was placed in
1008          BINDING_VALUE because it was thought, at the point it was
1009          declared, to be the only entity with such a name.  Move the
1010          type name into the type slot; it is now hidden by the new
1011          binding.  */
1012       BINDING_TYPE (binding) = BINDING_VALUE (binding);
1013       BINDING_VALUE (binding) = decl;
1014       INHERITED_VALUE_BINDING_P (binding) = 0;
1015     }
1016   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
1017            && TREE_CODE (decl) == TYPE_DECL
1018            && DECL_NAME (decl) == DECL_NAME (BINDING_VALUE (binding))
1019            && same_type_p (TREE_TYPE (decl),
1020                            TREE_TYPE (BINDING_VALUE (binding))))
1021     /* We have two typedef-names, both naming the same type to have
1022        the same name.  This is OK because of:
1023
1024          [dcl.typedef]
1025
1026          In a given scope, a typedef specifier can be used to redefine
1027          the name of any type declared in that scope to refer to the
1028          type to which it already refers.  */
1029     ok = 0;
1030   /* There can be two block-scope declarations of the same variable,
1031      so long as they are `extern' declarations.  */
1032   else if (TREE_CODE (decl) == VAR_DECL
1033            && TREE_CODE (BINDING_VALUE (binding)) == VAR_DECL
1034            && DECL_EXTERNAL (decl)
1035            && DECL_EXTERNAL (BINDING_VALUE (binding)))
1036     {
1037       duplicate_decls (decl, BINDING_VALUE (binding));
1038       ok = 0;
1039     }
1040   else
1041     {
1042       cp_error ("declaration of `%#D'", decl);
1043       cp_error_at ("conflicts with previous declaration `%#D'",
1044                    BINDING_VALUE (binding));
1045       ok = 0;
1046     }
1047
1048   return ok;
1049 }
1050
1051 /* Add DECL to the list of things declared in B.  */
1052
1053 static void
1054 add_decl_to_level (decl, b)
1055      tree decl;
1056      struct binding_level *b;
1057 {
1058   /* We build up the list in reverse order, and reverse it later if
1059      necessary.  */
1060   TREE_CHAIN (decl) = b->names;
1061   b->names = decl;
1062 }
1063
1064 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1065    binding level.  If PUSH_USING is set in FLAGS, we know that DECL
1066    doesn't really belong to this binding level, that it got here
1067    through a using-declaration.  */
1068
1069 void
1070 push_local_binding (id, decl, flags)
1071      tree id;
1072      tree decl;
1073      int flags;
1074 {
1075   struct binding_level *b;
1076
1077   /* Skip over any local classes.  This makes sense if we call
1078      push_local_binding with a friend decl of a local class.  */
1079   b = current_binding_level;
1080   while (b->parm_flag == 2)
1081     b = b->level_chain;
1082
1083   if (lookup_name_current_level (id))
1084     {
1085       /* Supplement the existing binding.  */
1086       if (!add_binding (id, decl))
1087         /* It didn't work.  Something else must be bound at this
1088            level.  Do not add DECL to the list of things to pop
1089            later.  */
1090         return;
1091     }
1092   else
1093     /* Create a new binding.  */
1094     push_binding (id, decl, b);
1095
1096   if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1097     /* We must put the OVERLOAD into a TREE_LIST since the
1098        TREE_CHAIN of an OVERLOAD is already used.  Similarly for
1099        decls that got here through a using-declaration.  */
1100     decl = build_tree_list (NULL_TREE, decl);
1101
1102   /* And put DECL on the list of things declared by the current
1103      binding level.  */
1104   add_decl_to_level (decl, b);
1105 }
1106
1107 /* Bind DECL to ID in the class_binding_level.  Returns nonzero if the
1108    binding was successful.  */
1109
1110 int
1111 push_class_binding (id, decl)
1112      tree id;
1113      tree decl;
1114 {
1115   int result = 1;
1116   tree binding = IDENTIFIER_BINDING (id);
1117   tree context;
1118
1119   /* Note that we declared this value so that we can issue an error if
1120      this an illegal redeclaration of a name already used for some
1121      other purpose.  */
1122   note_name_declared_in_class (id, decl);
1123
1124   if (binding && BINDING_LEVEL (binding) == class_binding_level)
1125     /* Supplement the existing binding.  */
1126     result = add_binding (id, decl);
1127   else
1128     /* Create a new binding.  */
1129     push_binding (id, decl, class_binding_level);
1130
1131   /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1132      class-level declaration.  Note that we do not use DECL here
1133      because of the possibility of the `struct stat' hack; if DECL is
1134      a class-name or enum-name we might prefer a field-name, or some
1135      such.  */
1136   IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
1137
1138   /* If this is a binding from a base class, mark it as such.  */
1139   binding = IDENTIFIER_BINDING (id);
1140   if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
1141     {
1142       /* Any implicit typename must be from a base-class.  The
1143          context for an implicit typename declaration is always
1144          the derived class in which the lookup was done, so the checks
1145          based on the context of DECL below will not trigger.  */
1146       if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl))
1147         INHERITED_VALUE_BINDING_P (binding) = 1;
1148       else
1149         {
1150           if (TREE_CODE (decl) == OVERLOAD)
1151             context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
1152           else
1153             {
1154               my_friendly_assert (DECL_P (decl), 0);
1155               context = context_for_name_lookup (decl);
1156             }
1157
1158           if (is_properly_derived_from (current_class_type, context))
1159             INHERITED_VALUE_BINDING_P (binding) = 1;
1160           else
1161             INHERITED_VALUE_BINDING_P (binding) = 0;
1162         }
1163     }
1164   else if (BINDING_VALUE (binding) == decl)
1165     /* We only encounter a TREE_LIST when push_class_decls detects an
1166        ambiguity.  Such an ambiguity can be overridden by a definition
1167        in this class.  */
1168     INHERITED_VALUE_BINDING_P (binding) = 1;
1169
1170   return result;
1171 }
1172
1173 /* Remove the binding for DECL which should be the innermost binding
1174    for ID.  */
1175
1176 static void
1177 pop_binding (id, decl)
1178      tree id;
1179      tree decl;
1180 {
1181   tree binding;
1182
1183   if (id == NULL_TREE)
1184     /* It's easiest to write the loops that call this function without
1185        checking whether or not the entities involved have names.  We
1186        get here for such an entity.  */
1187     return;
1188
1189   /* Get the innermost binding for ID.  */
1190   binding = IDENTIFIER_BINDING (id);
1191
1192   /* The name should be bound.  */
1193   my_friendly_assert (binding != NULL_TREE, 0);
1194
1195   /* The DECL will be either the ordinary binding or the type
1196      binding for this identifier.  Remove that binding.  */
1197   if (BINDING_VALUE (binding) == decl)
1198     BINDING_VALUE (binding) = NULL_TREE;
1199   else if (BINDING_TYPE (binding) == decl)
1200     BINDING_TYPE (binding) = NULL_TREE;
1201   else
1202     my_friendly_abort (0);
1203
1204   if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
1205     {
1206       /* We're completely done with the innermost binding for this
1207          identifier.  Unhook it from the list of bindings.  */
1208       IDENTIFIER_BINDING (id) = TREE_CHAIN (binding);
1209
1210       /* Add it to the free list.  */
1211       TREE_CHAIN (binding) = free_bindings;
1212       free_bindings = binding;
1213
1214       /* Clear the BINDING_LEVEL so the garbage collector doesn't walk
1215          it.  */
1216       BINDING_LEVEL (binding) = NULL;
1217     }
1218 }
1219
1220 /* When a label goes out of scope, check to see if that label was used
1221    in a valid manner, and issue any appropriate warnings or errors.  */
1222
1223 static void
1224 pop_label (label, old_value)
1225      tree label;
1226      tree old_value;
1227 {
1228   if (!processing_template_decl && doing_semantic_analysis_p ())
1229     {
1230       if (DECL_INITIAL (label) == NULL_TREE)
1231         {
1232           cp_error_at ("label `%D' used but not defined", label);
1233           /* Avoid crashing later.  */
1234           define_label (input_filename, 1, DECL_NAME (label));
1235         }
1236       else if (warn_unused_label && !TREE_USED (label))
1237         cp_warning_at ("label `%D' defined but not used", label);
1238     }
1239
1240   SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
1241 }
1242
1243 /* At the end of a function, all labels declared within the function
1244    go out of scope.  BLOCK is the top-level block for the
1245    function.  */
1246
1247 static void
1248 pop_labels (block)
1249      tree block;
1250 {
1251   struct named_label_list *link;
1252
1253   /* Clear out the definitions of all label names, since their scopes
1254      end here.  */
1255   for (link = named_labels; link; link = link->next)
1256     {
1257       pop_label (link->label_decl, link->old_value);
1258       /* Put the labels into the "variables" of the top-level block,
1259          so debugger can see them.  */
1260       TREE_CHAIN (link->label_decl) = BLOCK_VARS (block);
1261       BLOCK_VARS (block) = link->label_decl;
1262     }
1263
1264   named_labels = NULL;
1265 }
1266
1267 /* Exit a binding level.
1268    Pop the level off, and restore the state of the identifier-decl mappings
1269    that were in effect when this level was entered.
1270
1271    If KEEP == 1, this level had explicit declarations, so
1272    and create a "block" (a BLOCK node) for the level
1273    to record its declarations and subblocks for symbol table output.
1274
1275    If FUNCTIONBODY is nonzero, this level is the body of a function,
1276    so create a block as if KEEP were set and also clear out all
1277    label names.
1278
1279    If REVERSE is nonzero, reverse the order of decls before putting
1280    them into the BLOCK.  */
1281
1282 tree
1283 poplevel (keep, reverse, functionbody)
1284      int keep;
1285      int reverse;
1286      int functionbody;
1287 {
1288   register tree link;
1289   /* The chain of decls was accumulated in reverse order.
1290      Put it into forward order, just for cleanliness.  */
1291   tree decls;
1292   int tmp = functionbody;
1293   int real_functionbody;
1294   tree tags;
1295   tree subblocks;
1296   tree block = NULL_TREE;
1297   tree decl;
1298   int leaving_for_scope;
1299
1300   if (cfun && !doing_semantic_analysis_p ())
1301     return NULL_TREE;
1302
1303   my_friendly_assert (current_binding_level->parm_flag != 2,
1304                       19990916);
1305
1306   real_functionbody = (current_binding_level->keep == 2
1307                        ? ((functionbody = 0), tmp) : functionbody);
1308   tags = functionbody >= 0 ? current_binding_level->tags : 0;
1309   subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1310
1311   my_friendly_assert (!current_binding_level->class_shadowed,
1312                       19990414);
1313
1314   /* We used to use KEEP == 2 to indicate that the new block should go
1315      at the beginning of the list of blocks at this binding level,
1316      rather than the end.  This hack is no longer used.  */
1317   my_friendly_assert (keep == 0 || keep == 1, 0);
1318
1319   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
1320                       (HOST_WIDE_INT) current_binding_level->level_chain,
1321                       current_binding_level->parm_flag,
1322                       current_binding_level->keep);
1323
1324   if (current_binding_level->keep == 1)
1325     keep = 1;
1326
1327   /* Any uses of undefined labels, and any defined labels, now operate
1328      under constraints of next binding contour.  */
1329   if (cfun && !functionbody)
1330     {
1331       struct binding_level *level_chain;
1332       level_chain = current_binding_level->level_chain;
1333       if (level_chain)
1334         {
1335           struct named_label_use_list *uses;
1336           struct named_label_list *labels;
1337           for (labels = named_labels; labels; labels = labels->next)
1338             if (labels->binding_level == current_binding_level)
1339               {
1340                 tree decl;
1341                 if (current_binding_level->is_try_scope)
1342                   labels->in_try_scope = 1;
1343                 if (current_binding_level->is_catch_scope)
1344                   labels->in_catch_scope = 1;
1345                 for (decl = labels->names_in_scope; decl;
1346                      decl = TREE_CHAIN (decl))
1347                   if (decl_jump_unsafe (decl))
1348                     labels->bad_decls = tree_cons (NULL_TREE, decl,
1349                                                    labels->bad_decls);
1350                 labels->binding_level = level_chain;
1351                 labels->names_in_scope = level_chain->names;
1352               }
1353
1354           for (uses = named_label_uses; uses; uses = uses->next)
1355             if (uses->binding_level == current_binding_level)
1356               {
1357                 uses->binding_level = level_chain;
1358                 uses->names_in_scope = level_chain->names;
1359               }
1360         }
1361     }
1362
1363   /* Get the decls in the order they were written.
1364      Usually current_binding_level->names is in reverse order.
1365      But parameter decls were previously put in forward order.  */
1366
1367   if (reverse)
1368     current_binding_level->names
1369       = decls = nreverse (current_binding_level->names);
1370   else
1371     decls = current_binding_level->names;
1372
1373   /* Output any nested inline functions within this block
1374      if they weren't already output.  */
1375   for (decl = decls; decl; decl = TREE_CHAIN (decl))
1376     if (TREE_CODE (decl) == FUNCTION_DECL
1377         && ! TREE_ASM_WRITTEN (decl)
1378         && DECL_INITIAL (decl) != NULL_TREE
1379         && TREE_ADDRESSABLE (decl)
1380         && decl_function_context (decl) == current_function_decl)
1381       {
1382         /* If this decl was copied from a file-scope decl
1383            on account of a block-scope extern decl,
1384            propagate TREE_ADDRESSABLE to the file-scope decl.  */
1385         if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1386           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1387         else
1388           {
1389             push_function_context ();
1390             output_inline_function (decl);
1391             pop_function_context ();
1392           }
1393       }
1394
1395   /* When not in function-at-a-time mode, expand_end_bindings will
1396      warn about unused variables.  But, in function-at-a-time mode
1397      expand_end_bindings is not passed the list of variables in the
1398      current scope, and therefore no warning is emitted.  So, we
1399      explicitly warn here.  */
1400   if (!processing_template_decl)
1401     warn_about_unused_variables (getdecls ());
1402
1403   /* If there were any declarations or structure tags in that level,
1404      or if this level is a function body,
1405      create a BLOCK to record them for the life of this function.  */
1406   block = NULL_TREE;
1407   if (keep == 1 || functionbody)
1408     block = make_node (BLOCK);
1409   if (block != NULL_TREE)
1410     {
1411       BLOCK_VARS (block) = decls;
1412       BLOCK_SUBBLOCKS (block) = subblocks;
1413     }
1414
1415   /* In each subblock, record that this is its superior.  */
1416   if (keep >= 0)
1417     for (link = subblocks; link; link = TREE_CHAIN (link))
1418       BLOCK_SUPERCONTEXT (link) = block;
1419
1420   /* We still support the old for-scope rules, whereby the variables
1421      in a for-init statement were in scope after the for-statement
1422      ended.  We only use the new rules in flag_new_for_scope is
1423      nonzero.  */
1424   leaving_for_scope
1425     = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1426
1427   /* Remove declarations for all the DECLs in this level.  */
1428   for (link = decls; link; link = TREE_CHAIN (link))
1429     {
1430       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
1431           && DECL_NAME (link))
1432         {
1433           tree outer_binding
1434             = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1435           tree ns_binding;
1436
1437           if (!outer_binding)
1438             ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1439           else
1440             ns_binding = NULL_TREE;
1441
1442           if (outer_binding
1443               && (BINDING_LEVEL (outer_binding)
1444                   == current_binding_level->level_chain))
1445             /* We have something like:
1446
1447                  int i;
1448                  for (int i; ;);
1449
1450                and we are leaving the `for' scope.  There's no reason to
1451                keep the binding of the inner `i' in this case.  */
1452             pop_binding (DECL_NAME (link), link);
1453           else if ((outer_binding
1454                     && (TREE_CODE (BINDING_VALUE (outer_binding))
1455                         == TYPE_DECL))
1456                    || (ns_binding
1457                        && TREE_CODE (ns_binding) == TYPE_DECL))
1458             /* Here, we have something like:
1459
1460                  typedef int I;
1461
1462                  void f () {
1463                    for (int I; ;);
1464                  }
1465
1466                We must pop the for-scope binding so we know what's a
1467                type and what isn't.  */
1468             pop_binding (DECL_NAME (link), link);
1469           else
1470             {
1471               /* Mark this VAR_DECL as dead so that we can tell we left it
1472                  there only for backward compatibility.  */
1473               DECL_DEAD_FOR_LOCAL (link) = 1;
1474
1475               /* Keep track of what should of have happenned when we
1476                  popped the binding.  */
1477               if (outer_binding && BINDING_VALUE (outer_binding))
1478                 DECL_SHADOWED_FOR_VAR (link)
1479                   = BINDING_VALUE (outer_binding);
1480
1481               /* Add it to the list of dead variables in the next
1482                  outermost binding to that we can remove these when we
1483                  leave that binding.  */
1484               current_binding_level->level_chain->dead_vars_from_for
1485                 = tree_cons (NULL_TREE, link,
1486                              current_binding_level->level_chain->
1487                              dead_vars_from_for);
1488
1489               /* Although we don't pop the CPLUS_BINDING, we do clear
1490                  its BINDING_LEVEL since the level is going away now.  */
1491               BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1492                 = 0;
1493             }
1494         }
1495       else
1496         {
1497           /* Remove the binding.  */
1498           decl = link;
1499           if (TREE_CODE (decl) == TREE_LIST)
1500             decl = TREE_VALUE (decl);
1501           if (DECL_P (decl))
1502             pop_binding (DECL_NAME (decl), decl);
1503           else if (TREE_CODE (decl) == OVERLOAD)
1504             pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1505           else
1506             my_friendly_abort (0);
1507         }
1508     }
1509
1510   /* Remove declarations for any `for' variables from inner scopes
1511      that we kept around.  */
1512   for (link = current_binding_level->dead_vars_from_for;
1513        link; link = TREE_CHAIN (link))
1514     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1515
1516   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
1517   for (link = current_binding_level->type_shadowed;
1518        link; link = TREE_CHAIN (link))
1519     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1520
1521   /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
1522   for (link = current_binding_level->shadowed_labels;
1523        link;
1524        link = TREE_CHAIN (link))
1525     pop_label (TREE_VALUE (link), TREE_PURPOSE (link));
1526
1527   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1528      list if a `using' declaration put them there.  The debugging
1529      back-ends won't understand OVERLOAD, so we remove them here.
1530      Because the BLOCK_VARS are (temporarily) shared with
1531      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1532      popped all the bindings.  */
1533   if (block)
1534     {
1535       tree* d;
1536
1537       for (d = &BLOCK_VARS (block); *d; )
1538         {
1539           if (TREE_CODE (*d) == TREE_LIST)
1540             *d = TREE_CHAIN (*d);
1541           else
1542             d = &TREE_CHAIN (*d);
1543         }
1544     }
1545
1546   /* If the level being exited is the top level of a function,
1547      check over all the labels.  */
1548   if (functionbody)
1549     {
1550       /* Since this is the top level block of a function, the vars are
1551          the function's parameters.  Don't leave them in the BLOCK
1552          because they are found in the FUNCTION_DECL instead.  */
1553       BLOCK_VARS (block) = 0;
1554       pop_labels (block);
1555     }
1556
1557   tmp = current_binding_level->keep;
1558
1559   pop_binding_level ();
1560   if (functionbody)
1561     DECL_INITIAL (current_function_decl) = block;
1562   else if (block)
1563     current_binding_level->blocks
1564       = chainon (current_binding_level->blocks, block);
1565
1566   /* If we did not make a block for the level just exited,
1567      any blocks made for inner levels
1568      (since they cannot be recorded as subblocks in that level)
1569      must be carried forward so they will later become subblocks
1570      of something else.  */
1571   else if (subblocks)
1572     current_binding_level->blocks
1573       = chainon (current_binding_level->blocks, subblocks);
1574
1575   /* Each and every BLOCK node created here in `poplevel' is important
1576      (e.g. for proper debugging information) so if we created one
1577      earlier, mark it as "used".  */
1578   if (block)
1579     TREE_USED (block) = 1;
1580
1581   /* Take care of compiler's internal binding structures.  */
1582   if (tmp == 2)
1583     {
1584       tree scope_stmts;
1585
1586       scope_stmts
1587         = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1588       if (block)
1589         {
1590           SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1591           SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1592         }
1593
1594       block = poplevel (keep, reverse, functionbody);
1595     }
1596
1597   return block;
1598 }
1599
1600 /* Delete the node BLOCK from the current binding level.
1601    This is used for the block inside a stmt expr ({...})
1602    so that the block can be reinserted where appropriate.  */
1603
1604 void
1605 delete_block (block)
1606      tree block;
1607 {
1608   tree t;
1609   if (current_binding_level->blocks == block)
1610     current_binding_level->blocks = TREE_CHAIN (block);
1611   for (t = current_binding_level->blocks; t;)
1612     {
1613       if (TREE_CHAIN (t) == block)
1614         TREE_CHAIN (t) = TREE_CHAIN (block);
1615       else
1616         t = TREE_CHAIN (t);
1617     }
1618   TREE_CHAIN (block) = NULL_TREE;
1619   /* Clear TREE_USED which is always set by poplevel.
1620      The flag is set again if insert_block is called.  */
1621   TREE_USED (block) = 0;
1622 }
1623
1624 /* Insert BLOCK at the end of the list of subblocks of the
1625    current binding level.  This is used when a BIND_EXPR is expanded,
1626    to handle the BLOCK node inside the BIND_EXPR.  */
1627
1628 void
1629 insert_block (block)
1630      tree block;
1631 {
1632   TREE_USED (block) = 1;
1633   current_binding_level->blocks
1634     = chainon (current_binding_level->blocks, block);
1635 }
1636
1637 /* Set the BLOCK node for the innermost scope
1638    (the one we are currently in).  */
1639
1640 void
1641 set_block (block)
1642     tree block ATTRIBUTE_UNUSED;
1643 {
1644   /* The RTL expansion machinery requires us to provide this callback,
1645      but it is not applicable in function-at-a-time mode.  */
1646   my_friendly_assert (cfun && !doing_semantic_analysis_p (), 20000911);
1647 }
1648
1649 /* Do a pushlevel for class declarations.  */
1650
1651 void
1652 pushlevel_class ()
1653 {
1654   register struct binding_level *newlevel;
1655
1656   /* Reuse or create a struct for this binding level.  */
1657 #if defined(DEBUG_CP_BINDING_LEVELS)
1658   if (0)
1659 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1660   if (free_binding_level)
1661 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1662     {
1663       newlevel = free_binding_level;
1664       free_binding_level = free_binding_level->level_chain;
1665     }
1666   else
1667     newlevel = make_binding_level ();
1668
1669 #if defined(DEBUG_CP_BINDING_LEVELS)
1670   is_class_level = 1;
1671 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1672
1673   push_binding_level (newlevel, 0, 0);
1674
1675   class_binding_level = current_binding_level;
1676   class_binding_level->parm_flag = 2;
1677   class_binding_level->this_class = current_class_type;
1678 }
1679
1680 /* ...and a poplevel for class declarations.  */
1681
1682 void
1683 poplevel_class ()
1684 {
1685   register struct binding_level *level = class_binding_level;
1686   tree shadowed;
1687
1688   my_friendly_assert (level != 0, 354);
1689
1690   /* If we're leaving a toplevel class, don't bother to do the setting
1691      of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1692      shouldn't even be used when current_class_type isn't set, and second,
1693      if we don't touch it here, we're able to use the cache effect if the
1694      next time we're entering a class scope, it is the same class.  */
1695   if (current_class_depth != 1)
1696     {
1697       struct binding_level* b;
1698
1699       /* Clear out our IDENTIFIER_CLASS_VALUEs.  */
1700       for (shadowed = level->class_shadowed;
1701            shadowed;
1702            shadowed = TREE_CHAIN (shadowed))
1703         IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1704
1705       /* Find the next enclosing class, and recreate
1706          IDENTIFIER_CLASS_VALUEs appropriate for that class.  */
1707       b = level->level_chain;
1708       while (b && b->parm_flag != 2)
1709         b = b->level_chain;
1710
1711       if (b)
1712         for (shadowed = b->class_shadowed;
1713              shadowed;
1714              shadowed = TREE_CHAIN (shadowed))
1715           {
1716             tree t;
1717
1718             t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1719             while (t && BINDING_LEVEL (t) != b)
1720               t = TREE_CHAIN (t);
1721
1722             if (t)
1723               IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1724                 = BINDING_VALUE (t);
1725           }
1726     }
1727   else
1728     /* Remember to save what IDENTIFIER's were bound in this scope so we
1729        can recover from cache misses.  */
1730     {
1731       previous_class_type = current_class_type;
1732       previous_class_values = class_binding_level->class_shadowed;
1733     }
1734   for (shadowed = level->type_shadowed;
1735        shadowed;
1736        shadowed = TREE_CHAIN (shadowed))
1737     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1738
1739   /* Remove the bindings for all of the class-level declarations.  */
1740   for (shadowed = level->class_shadowed;
1741        shadowed;
1742        shadowed = TREE_CHAIN (shadowed))
1743     pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1744
1745   GNU_xref_end_scope ((HOST_WIDE_INT) class_binding_level,
1746                       (HOST_WIDE_INT) class_binding_level->level_chain,
1747                       class_binding_level->parm_flag,
1748                       class_binding_level->keep);
1749
1750   /* Now, pop out of the binding level which we created up in the
1751      `pushlevel_class' routine.  */
1752 #if defined(DEBUG_CP_BINDING_LEVELS)
1753   is_class_level = 1;
1754 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1755
1756   pop_binding_level ();
1757 }
1758
1759 /* We are entering the scope of a class.  Clear IDENTIFIER_CLASS_VALUE
1760    for any names in enclosing classes.  */
1761
1762 void
1763 clear_identifier_class_values ()
1764 {
1765   tree t;
1766
1767   if (!class_binding_level)
1768     return;
1769
1770   for (t = class_binding_level->class_shadowed;
1771        t;
1772        t = TREE_CHAIN (t))
1773     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1774 }
1775
1776 /* Returns non-zero if T is a virtual function table.  */
1777
1778 int
1779 vtable_decl_p (t, data)
1780      tree t;
1781      void *data ATTRIBUTE_UNUSED;
1782 {
1783   return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1784 }
1785
1786 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1787    functions.  */
1788
1789 int
1790 vtype_decl_p (t, data)
1791      tree t;
1792      void *data ATTRIBUTE_UNUSED;
1793 {
1794   return (TREE_CODE (t) == TYPE_DECL
1795           && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE
1796           && TYPE_POLYMORPHIC_P (TREE_TYPE (t)));
1797 }
1798
1799 /* Return the declarations that are members of the namespace NS.  */
1800
1801 tree
1802 cp_namespace_decls (ns)
1803      tree ns;
1804 {
1805   return NAMESPACE_LEVEL (ns)->names;
1806 }
1807
1808 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1809    itself, calling F for each.  The DATA is passed to F as well.  */
1810
1811 static int
1812 walk_namespaces_r (namespace, f, data)
1813      tree namespace;
1814      walk_namespaces_fn f;
1815      void *data;
1816 {
1817   tree current;
1818   int result = 0;
1819
1820   result |= (*f) (namespace, data);
1821
1822   for (current = cp_namespace_decls (namespace);
1823        current;
1824        current = TREE_CHAIN (current))
1825     {
1826       if (TREE_CODE (current) != NAMESPACE_DECL
1827           || DECL_NAMESPACE_ALIAS (current))
1828         continue;
1829       if (!DECL_LANG_SPECIFIC (current))
1830         {
1831           /* Hmm. std. */
1832           my_friendly_assert (current == fake_std_node, 393);
1833           continue;
1834         }
1835
1836       /* We found a namespace.  */
1837       result |= walk_namespaces_r (current, f, data);
1838     }
1839
1840   return result;
1841 }
1842
1843 /* Walk all the namespaces, calling F for each.  The DATA is passed to
1844    F as well.  */
1845
1846 int
1847 walk_namespaces (f, data)
1848      walk_namespaces_fn f;
1849      void *data;
1850 {
1851   return walk_namespaces_r (global_namespace, f, data);
1852 }
1853
1854 struct walk_globals_data {
1855   walk_globals_pred p;
1856   walk_globals_fn f;
1857   void *data;
1858 };
1859
1860 /* Walk the global declarations in NAMESPACE.  Whenever one is found
1861    for which P returns non-zero, call F with its address.  If any call
1862    to F returns a non-zero value, return a non-zero value.  */
1863
1864 static int
1865 walk_globals_r (namespace, data)
1866      tree namespace;
1867      void *data;
1868 {
1869   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1870   walk_globals_pred p = wgd->p;
1871   walk_globals_fn f = wgd->f;
1872   void *d = wgd->data;
1873   tree *t;
1874   int result = 0;
1875
1876   t = &NAMESPACE_LEVEL (namespace)->names;
1877
1878   while (*t)
1879     {
1880       tree glbl = *t;
1881
1882       if ((*p) (glbl, d))
1883         result |= (*f) (t, d);
1884
1885       /* If F changed *T, then *T still points at the next item to
1886          examine.  */
1887       if (*t == glbl)
1888         t = &TREE_CHAIN (*t);
1889     }
1890
1891   return result;
1892 }
1893
1894 /* Walk the global declarations.  Whenever one is found for which P
1895    returns non-zero, call F with its address.  If any call to F
1896    returns a non-zero value, return a non-zero value.  */
1897
1898 int
1899 walk_globals (p, f, data)
1900      walk_globals_pred p;
1901      walk_globals_fn f;
1902      void *data;
1903 {
1904   struct walk_globals_data wgd;
1905   wgd.p = p;
1906   wgd.f = f;
1907   wgd.data = data;
1908
1909   return walk_namespaces (walk_globals_r, &wgd);
1910 }
1911
1912 /* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
1913    DATA is non-NULL, this is the last time we will call
1914    wrapup_global_declarations for this NAMESPACE.  */
1915
1916 int
1917 wrapup_globals_for_namespace (namespace, data)
1918      tree namespace;
1919      void *data;
1920 {
1921   tree globals = cp_namespace_decls (namespace);
1922   int len = list_length (globals);
1923   tree *vec = (tree *) alloca (sizeof (tree) * len);
1924   int i;
1925   int result;
1926   tree decl;
1927   int last_time = (data != 0);
1928
1929   if (last_time && namespace == global_namespace)
1930     /* Let compile_file handle the global namespace.  */
1931     return 0;
1932
1933   /* Process the decls in reverse order--earliest first.
1934      Put them into VEC from back to front, then take out from front.  */
1935   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1936     vec[len - i - 1] = decl;
1937
1938   if (last_time)
1939     {
1940       check_global_declarations (vec, len);
1941       return 0;
1942     }
1943
1944   /* Temporarily mark vtables as external.  That prevents
1945      wrapup_global_declarations from writing them out; we must process
1946      them ourselves in finish_vtable_vardecl.  */
1947   for (i = 0; i < len; ++i)
1948     if (vtable_decl_p (vec[i], /*data=*/0) && !DECL_EXTERNAL (vec[i]))
1949       {
1950         DECL_NOT_REALLY_EXTERN (vec[i]) = 1;
1951         DECL_EXTERNAL (vec[i]) = 1;
1952       }
1953
1954   /* Write out any globals that need to be output.  */
1955   result = wrapup_global_declarations (vec, len);
1956
1957   /* Undo the hack to DECL_EXTERNAL above.  */
1958   for (i = 0; i < len; ++i)
1959     if (vtable_decl_p (vec[i], /*data=*/0)
1960         && DECL_NOT_REALLY_EXTERN (vec[i]))
1961       {
1962         DECL_NOT_REALLY_EXTERN (vec[i]) = 0;
1963         DECL_EXTERNAL (vec[i]) = 0;
1964       }
1965
1966   return result;
1967 }
1968
1969 \f
1970 /* Mark ARG (which is really a struct binding_level **) for GC.  */
1971
1972 static void
1973 mark_binding_level (arg)
1974      void *arg;
1975 {
1976   struct binding_level *lvl = *(struct binding_level **)arg;
1977
1978   for (; lvl; lvl = lvl->level_chain)
1979     {
1980       ggc_mark_tree (lvl->names);
1981       ggc_mark_tree (lvl->tags);
1982       ggc_mark_tree (lvl->usings);
1983       ggc_mark_tree (lvl->using_directives);
1984       ggc_mark_tree (lvl->class_shadowed);
1985       ggc_mark_tree (lvl->type_shadowed);
1986       ggc_mark_tree (lvl->shadowed_labels);
1987       ggc_mark_tree (lvl->blocks);
1988       ggc_mark_tree (lvl->this_class);
1989       ggc_mark_tree (lvl->incomplete);
1990       ggc_mark_tree (lvl->dead_vars_from_for);
1991     }
1992 }
1993
1994 static void
1995 mark_named_label_lists (labs, uses)
1996      void *labs;
1997      void *uses;
1998 {
1999   struct named_label_list *l = *(struct named_label_list **)labs;
2000   struct named_label_use_list *u = *(struct named_label_use_list **)uses;
2001
2002   for (; l; l = l->next)
2003     {
2004       ggc_mark (l);
2005       mark_binding_level (l->binding_level);
2006       ggc_mark_tree (l->old_value);
2007       ggc_mark_tree (l->label_decl);
2008       ggc_mark_tree (l->bad_decls);
2009     }
2010
2011   for (; u; u = u->next)
2012     ggc_mark (u);
2013 }
2014 \f
2015 /* For debugging.  */
2016 static int no_print_functions = 0;
2017 static int no_print_builtins = 0;
2018
2019 void
2020 print_binding_level (lvl)
2021      struct binding_level *lvl;
2022 {
2023   tree t;
2024   int i = 0, len;
2025   fprintf (stderr, " blocks=");
2026   fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
2027   fprintf (stderr, " n_incomplete=%d parm_flag=%d keep=%d",
2028            list_length (lvl->incomplete), lvl->parm_flag, lvl->keep);
2029   if (lvl->tag_transparent)
2030     fprintf (stderr, " tag-transparent");
2031   if (lvl->more_cleanups_ok)
2032     fprintf (stderr, " more-cleanups-ok");
2033   if (lvl->have_cleanups)
2034     fprintf (stderr, " have-cleanups");
2035   fprintf (stderr, "\n");
2036   if (lvl->names)
2037     {
2038       fprintf (stderr, " names:\t");
2039       /* We can probably fit 3 names to a line?  */
2040       for (t = lvl->names; t; t = TREE_CHAIN (t))
2041         {
2042           if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
2043             continue;
2044           if (no_print_builtins
2045               && (TREE_CODE (t) == TYPE_DECL)
2046               && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
2047             continue;
2048
2049           /* Function decls tend to have longer names.  */
2050           if (TREE_CODE (t) == FUNCTION_DECL)
2051             len = 3;
2052           else
2053             len = 2;
2054           i += len;
2055           if (i > 6)
2056             {
2057               fprintf (stderr, "\n\t");
2058               i = len;
2059             }
2060           print_node_brief (stderr, "", t, 0);
2061           if (t == error_mark_node)
2062             break;
2063         }
2064       if (i)
2065         fprintf (stderr, "\n");
2066     }
2067   if (lvl->tags)
2068     {
2069       fprintf (stderr, " tags:\t");
2070       i = 0;
2071       for (t = lvl->tags; t; t = TREE_CHAIN (t))
2072         {
2073           if (TREE_PURPOSE (t) == NULL_TREE)
2074             len = 3;
2075           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2076             len = 2;
2077           else
2078             len = 4;
2079           i += len;
2080           if (i > 5)
2081             {
2082               fprintf (stderr, "\n\t");
2083               i = len;
2084             }
2085           if (TREE_PURPOSE (t) == NULL_TREE)
2086             {
2087               print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
2088               fprintf (stderr, ">");
2089             }
2090           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2091             print_node_brief (stderr, "", TREE_VALUE (t), 0);
2092           else
2093             {
2094               print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
2095               print_node_brief (stderr, "", TREE_VALUE (t), 0);
2096               fprintf (stderr, ">");
2097             }
2098         }
2099       if (i)
2100         fprintf (stderr, "\n");
2101     }
2102   if (lvl->class_shadowed)
2103     {
2104       fprintf (stderr, " class-shadowed:");
2105       for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
2106         {
2107           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2108         }
2109       fprintf (stderr, "\n");
2110     }
2111   if (lvl->type_shadowed)
2112     {
2113       fprintf (stderr, " type-shadowed:");
2114       for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
2115         {
2116           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2117         }
2118       fprintf (stderr, "\n");
2119     }
2120 }
2121
2122 void
2123 print_other_binding_stack (stack)
2124      struct binding_level *stack;
2125 {
2126   struct binding_level *level;
2127   for (level = stack; level != global_binding_level; level = level->level_chain)
2128     {
2129       fprintf (stderr, "binding level ");
2130       fprintf (stderr, HOST_PTR_PRINTF, level);
2131       fprintf (stderr, "\n");
2132       print_binding_level (level);
2133     }
2134 }
2135
2136 void
2137 print_binding_stack ()
2138 {
2139   struct binding_level *b;
2140   fprintf (stderr, "current_binding_level=");
2141   fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
2142   fprintf (stderr, "\nclass_binding_level=");
2143   fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
2144   fprintf (stderr, "\nglobal_binding_level=");
2145   fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
2146   fprintf (stderr, "\n");
2147   if (class_binding_level)
2148     {
2149       for (b = class_binding_level; b; b = b->level_chain)
2150         if (b == current_binding_level)
2151           break;
2152       if (b)
2153         b = class_binding_level;
2154       else
2155         b = current_binding_level;
2156     }
2157   else
2158     b = current_binding_level;
2159   print_other_binding_stack (b);
2160   fprintf (stderr, "global:\n");
2161   print_binding_level (global_binding_level);
2162 }
2163
2164 /* Namespace binding access routines: The namespace_bindings field of
2165    the identifier is polymorphic, with three possible values:
2166    NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2167    indicating the BINDING_VALUE of global_namespace. */
2168
2169 /* Check whether the a binding for the name to scope is known.
2170    Assumes that the bindings of the name are already a list
2171    of bindings. Returns the binding found, or NULL_TREE. */
2172
2173 static tree
2174 find_binding (name, scope)
2175      tree name;
2176      tree scope;
2177 {
2178   tree iter, prev = NULL_TREE;
2179
2180   scope = ORIGINAL_NAMESPACE (scope);
2181
2182   for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2183        iter = TREE_CHAIN (iter))
2184     {
2185       my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2186       if (BINDING_SCOPE (iter) == scope)
2187         {
2188           /* Move binding found to the front of the list, so
2189              subsequent lookups will find it faster. */
2190           if (prev)
2191             {
2192               TREE_CHAIN (prev) = TREE_CHAIN (iter);
2193               TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2194               IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2195             }
2196           return iter;
2197         }
2198       prev = iter;
2199     }
2200   return NULL_TREE;
2201 }
2202
2203 /* Always returns a binding for name in scope. If the
2204    namespace_bindings is not a list, convert it to one first.
2205    If no binding is found, make a new one. */
2206
2207 tree
2208 binding_for_name (name, scope)
2209      tree name;
2210      tree scope;
2211 {
2212   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2213   tree result;
2214
2215   scope = ORIGINAL_NAMESPACE (scope);
2216
2217   if (b && TREE_CODE (b) != CPLUS_BINDING)
2218     {
2219       /* Get rid of optimization for global scope. */
2220       IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2221       BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2222       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2223     }
2224   if (b && (result = find_binding (name, scope)))
2225     return result;
2226   /* Not found, make a new one. */
2227   result = make_node (CPLUS_BINDING);
2228   TREE_CHAIN (result) = b;
2229   IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2230   BINDING_SCOPE (result) = scope;
2231   BINDING_TYPE (result) = NULL_TREE;
2232   BINDING_VALUE (result) = NULL_TREE;
2233   return result;
2234 }
2235
2236 /* Return the binding value for name in scope, considering that
2237    namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2238
2239 tree
2240 namespace_binding (name, scope)
2241      tree name;
2242      tree scope;
2243 {
2244   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2245   if (b == NULL_TREE)
2246     return NULL_TREE;
2247   if (scope == NULL_TREE)
2248     scope = global_namespace;
2249   if (TREE_CODE (b) != CPLUS_BINDING)
2250     return (scope == global_namespace) ? b : NULL_TREE;
2251   name = find_binding (name,scope);
2252   if (name == NULL_TREE)
2253     return name;
2254   return BINDING_VALUE (name);
2255 }
2256
2257 /* Set the binding value for name in scope. If modifying the binding
2258    of global_namespace is attempted, try to optimize it. */
2259
2260 void
2261 set_namespace_binding (name, scope, val)
2262      tree name;
2263      tree scope;
2264      tree val;
2265 {
2266   tree b;
2267
2268   if (scope == NULL_TREE)
2269     scope = global_namespace;
2270
2271   if (scope == global_namespace)
2272     {
2273       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2274       if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2275         {
2276           IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2277           return;
2278         }
2279     }
2280   b = binding_for_name (name, scope);
2281   BINDING_VALUE (b) = val;
2282 }
2283
2284 /* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
2285    select a name that is unique to this compilation unit.  */
2286
2287 void
2288 push_namespace (name)
2289      tree name;
2290 {
2291   tree d = NULL_TREE;
2292   int need_new = 1;
2293   int implicit_use = 0;
2294   int global = 0;
2295   if (!global_namespace)
2296     {
2297       /* This must be ::. */
2298       my_friendly_assert (name == get_identifier ("::"), 377);
2299       global = 1;
2300     }
2301   else if (!name)
2302     {
2303       /* The name of anonymous namespace is unique for the translation
2304          unit.  */
2305       if (!anonymous_namespace_name)
2306         anonymous_namespace_name = get_file_function_name ('N');
2307       name = anonymous_namespace_name;
2308       d = IDENTIFIER_NAMESPACE_VALUE (name);
2309       if (d)
2310         /* Reopening anonymous namespace.  */
2311         need_new = 0;
2312       implicit_use = 1;
2313     }
2314   else if (current_namespace == global_namespace
2315            && !flag_honor_std
2316            && name == std_identifier)
2317     {
2318       in_fake_std++;
2319       return;
2320     }
2321   else
2322     {
2323       /* Check whether this is an extended namespace definition. */
2324       d = IDENTIFIER_NAMESPACE_VALUE (name);
2325       if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2326         {
2327           need_new = 0;
2328           if (DECL_NAMESPACE_ALIAS (d))
2329             {
2330               cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
2331                         d, DECL_NAMESPACE_ALIAS (d));
2332               d = DECL_NAMESPACE_ALIAS (d);
2333             }
2334         }
2335     }
2336
2337   if (need_new)
2338     {
2339       /* Make a new namespace, binding the name to it. */
2340       d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2341       /* The global namespace is not pushed, and the global binding
2342          level is set elsewhere.  */
2343       if (!global)
2344         {
2345           DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
2346           d = pushdecl (d);
2347           pushlevel (0);
2348           declare_namespace_level ();
2349           NAMESPACE_LEVEL (d) = current_binding_level;
2350         }
2351     }
2352   else
2353     resume_binding_level (NAMESPACE_LEVEL (d));
2354
2355   if (implicit_use)
2356     do_using_directive (d);
2357   /* Enter the name space. */
2358   current_namespace = d;
2359 }
2360
2361 /* Pop from the scope of the current namespace.  */
2362
2363 void
2364 pop_namespace ()
2365 {
2366   if (current_namespace == global_namespace)
2367     {
2368       my_friendly_assert (in_fake_std > 0, 980421);
2369       in_fake_std--;
2370       return;
2371     }
2372   current_namespace = CP_DECL_CONTEXT (current_namespace);
2373   /* The binding level is not popped, as it might be re-opened later.  */
2374   suspend_binding_level ();
2375 }
2376
2377 /* Push into the scope of the namespace NS, even if it is deeply
2378    nested within another namespace.  */
2379
2380 void
2381 push_nested_namespace (ns)
2382      tree ns;
2383 {
2384   if (ns == global_namespace)
2385     push_to_top_level ();
2386   else
2387     {
2388       push_nested_namespace (CP_DECL_CONTEXT (ns));
2389       push_namespace (DECL_NAME (ns));
2390     }
2391 }
2392
2393 /* Pop back from the scope of the namespace NS, which was previously
2394    entered with push_nested_namespace.  */
2395
2396 void
2397 pop_nested_namespace (ns)
2398      tree ns;
2399 {
2400   while (ns != global_namespace)
2401     {
2402       pop_namespace ();
2403       ns = CP_DECL_CONTEXT (ns);
2404     }
2405
2406   pop_from_top_level ();
2407 }
2408
2409 \f
2410 /* Subroutines for reverting temporarily to top-level for instantiation
2411    of templates and such.  We actually need to clear out the class- and
2412    local-value slots of all identifiers, so that only the global values
2413    are at all visible.  Simply setting current_binding_level to the global
2414    scope isn't enough, because more binding levels may be pushed.  */
2415 struct saved_scope *scope_chain;
2416
2417 /* Mark ARG (which is really a struct saved_scope **) for GC.  */
2418
2419 static void
2420 mark_saved_scope (arg)
2421      void *arg;
2422 {
2423   struct saved_scope *t = *(struct saved_scope **)arg;
2424   while (t)
2425     {
2426       mark_binding_level (&t->class_bindings);
2427       ggc_mark_tree (t->old_bindings);
2428       ggc_mark_tree (t->old_namespace);
2429       ggc_mark_tree (t->class_name);
2430       ggc_mark_tree (t->class_type);
2431       ggc_mark_tree (t->access_specifier);
2432       ggc_mark_tree (t->function_decl);
2433       if (t->lang_base)
2434         ggc_mark_tree_varray (t->lang_base);
2435       ggc_mark_tree (t->lang_name);
2436       ggc_mark_tree (t->template_parms);
2437       ggc_mark_tree (t->x_previous_class_type);
2438       ggc_mark_tree (t->x_previous_class_values);
2439       ggc_mark_tree (t->x_saved_tree);
2440       ggc_mark_tree (t->incomplete);
2441       ggc_mark_tree (t->lookups);
2442
2443       mark_stmt_tree (&t->x_stmt_tree);
2444       mark_binding_level (&t->bindings);
2445       t = t->prev;
2446     }
2447 }
2448
2449 static tree
2450 store_bindings (names, old_bindings)
2451      tree names, old_bindings;
2452 {
2453   tree t;
2454   tree search_bindings = old_bindings;
2455
2456   for (t = names; t; t = TREE_CHAIN (t))
2457     {
2458       tree binding, t1, id;
2459
2460       if (TREE_CODE (t) == TREE_LIST)
2461         id = TREE_PURPOSE (t);
2462       else
2463         id = DECL_NAME (t);
2464
2465       if (!id
2466           /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2467              we have no IDENTIFIER_BINDING if we have left the class
2468              scope, but cached the class-level declarations.  */
2469           || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2470         continue;
2471
2472       for (t1 = search_bindings; t1; t1 = TREE_CHAIN (t1))
2473         if (TREE_VEC_ELT (t1, 0) == id)
2474           goto skip_it;
2475
2476       my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2477       binding = make_tree_vec (4);
2478       TREE_VEC_ELT (binding, 0) = id;
2479       TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2480       TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2481       TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2482       IDENTIFIER_BINDING (id) = NULL_TREE;
2483       IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2484       TREE_CHAIN (binding) = old_bindings;
2485       old_bindings = binding;
2486     skip_it:
2487       ;
2488     }
2489   return old_bindings;
2490 }
2491
2492 void
2493 maybe_push_to_top_level (pseudo)
2494      int pseudo;
2495 {
2496   struct saved_scope *s;
2497   struct binding_level *b;
2498   tree old_bindings;
2499   int need_pop;
2500
2501   s = (struct saved_scope *) xcalloc (1, sizeof (struct saved_scope));
2502
2503   b = scope_chain ? current_binding_level : 0;
2504
2505   /* If we're in the middle of some function, save our state.  */
2506   if (cfun)
2507     {
2508       need_pop = 1;
2509       push_function_context_to (NULL_TREE);
2510     }
2511   else
2512     need_pop = 0;
2513
2514   old_bindings = NULL_TREE;
2515   if (scope_chain && previous_class_type)
2516     old_bindings = store_bindings (previous_class_values, old_bindings);
2517
2518   /* Have to include global_binding_level, because class-level decls
2519      aren't listed anywhere useful.  */
2520   for (; b; b = b->level_chain)
2521     {
2522       tree t;
2523
2524       /* Template IDs are inserted into the global level. If they were
2525          inserted into namespace level, finish_file wouldn't find them
2526          when doing pending instantiations. Therefore, don't stop at
2527          namespace level, but continue until :: .  */
2528       if (b == global_binding_level || (pseudo && b->template_parms_p))
2529         break;
2530
2531       old_bindings = store_bindings (b->names, old_bindings);
2532       /* We also need to check class_shadowed to save class-level type
2533          bindings, since pushclass doesn't fill in b->names.  */
2534       if (b->parm_flag == 2)
2535         old_bindings = store_bindings (b->class_shadowed, old_bindings);
2536
2537       /* Unwind type-value slots back to top level.  */
2538       for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2539         SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2540     }
2541   s->prev = scope_chain;
2542   s->old_bindings = old_bindings;
2543   s->bindings = b;
2544   s->need_pop_function_context = need_pop;
2545   s->function_decl = current_function_decl;
2546
2547   scope_chain = s;
2548   current_function_decl = NULL_TREE;
2549   VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2550   current_lang_stack = &VARRAY_TREE (current_lang_base, 0);
2551   current_lang_name = lang_name_cplusplus;
2552   current_namespace = global_namespace;
2553 }
2554
2555 void
2556 push_to_top_level ()
2557 {
2558   maybe_push_to_top_level (0);
2559 }
2560
2561 void
2562 pop_from_top_level ()
2563 {
2564   struct saved_scope *s = scope_chain;
2565   tree t;
2566
2567   /* Clear out class-level bindings cache.  */
2568   if (previous_class_type)
2569     invalidate_class_lookup_cache ();
2570
2571   VARRAY_FREE (current_lang_base);
2572
2573   scope_chain = s->prev;
2574   for (t = s->old_bindings; t; t = TREE_CHAIN (t))
2575     {
2576       tree id = TREE_VEC_ELT (t, 0);
2577
2578       SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2579       IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2580       IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2581     }
2582
2583   /* If we were in the middle of compiling a function, restore our
2584      state.  */
2585   if (s->need_pop_function_context)
2586     pop_function_context_from (NULL_TREE);
2587   current_function_decl = s->function_decl;
2588
2589   free (s);
2590 }
2591 \f
2592 /* Push a definition of struct, union or enum tag "name".
2593    into binding_level "b".   "type" should be the type node,
2594    We assume that the tag "name" is not already defined.
2595
2596    Note that the definition may really be just a forward reference.
2597    In that case, the TYPE_SIZE will be a NULL_TREE.
2598
2599    C++ gratuitously puts all these tags in the name space.  */
2600
2601 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2602    record the shadowed value for this binding contour.  TYPE is
2603    the type that ID maps to.  */
2604
2605 static void
2606 set_identifier_type_value_with_scope (id, type, b)
2607      tree id;
2608      tree type;
2609      struct binding_level *b;
2610 {
2611   if (!b->namespace_p)
2612     {
2613       /* Shadow the marker, not the real thing, so that the marker
2614          gets restored later. */
2615       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2616       b->type_shadowed
2617         = tree_cons (id, old_type_value, b->type_shadowed);
2618     }
2619   else
2620     {
2621       tree binding = binding_for_name (id, current_namespace);
2622       BINDING_TYPE (binding) = type;
2623       /* Store marker instead of real type. */
2624       type = global_type_node;
2625     }
2626   SET_IDENTIFIER_TYPE_VALUE (id, type);
2627 }
2628
2629 /* As set_identifier_type_value_with_scope, but using current_binding_level.  */
2630
2631 void
2632 set_identifier_type_value (id, type)
2633      tree id;
2634      tree type;
2635 {
2636   set_identifier_type_value_with_scope (id, type, current_binding_level);
2637 }
2638
2639 /* Return the type associated with id. */
2640
2641 tree
2642 identifier_type_value (id)
2643      tree id;
2644 {
2645   /* There is no type with that name, anywhere. */
2646   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2647     return NULL_TREE;
2648   /* This is not the type marker, but the real thing. */
2649   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2650     return REAL_IDENTIFIER_TYPE_VALUE (id);
2651   /* Have to search for it. It must be on the global level, now.
2652      Ask lookup_name not to return non-types. */
2653   id = lookup_name_real (id, 2, 1, 0);
2654   if (id)
2655     return TREE_TYPE (id);
2656   return NULL_TREE;
2657 }
2658
2659 /* Pop off extraneous binding levels left over due to syntax errors.
2660
2661    We don't pop past namespaces, as they might be valid.  */
2662
2663 void
2664 pop_everything ()
2665 {
2666 #ifdef DEBUG_CP_BINDING_LEVELS
2667   fprintf (stderr, "XXX entering pop_everything ()\n");
2668 #endif
2669   while (!toplevel_bindings_p ())
2670     {
2671       if (current_binding_level->parm_flag == 2)
2672         pop_nested_class ();
2673       else
2674         poplevel (0, 0, 0);
2675     }
2676 #ifdef DEBUG_CP_BINDING_LEVELS
2677   fprintf (stderr, "XXX leaving pop_everything ()\n");
2678 #endif
2679 }
2680
2681 /* The type TYPE is being declared.  If it is a class template, or a
2682    specialization of a class template, do any processing required and
2683    perform error-checking.  If IS_FRIEND is non-zero, this TYPE is
2684    being declared a friend.  B is the binding level at which this TYPE
2685    should be bound.
2686
2687    Returns the TYPE_DECL for TYPE, which may have been altered by this
2688    processing.  */
2689
2690 static tree
2691 maybe_process_template_type_declaration (type, globalize, b)
2692      tree type;
2693      int globalize;
2694      struct binding_level* b;
2695 {
2696   tree decl = TYPE_NAME (type);
2697
2698   if (processing_template_parmlist)
2699     /* You can't declare a new template type in a template parameter
2700        list.  But, you can declare a non-template type:
2701
2702          template <class A*> struct S;
2703
2704        is a forward-declaration of `A'.  */
2705     ;
2706   else
2707     {
2708       maybe_check_template_type (type);
2709
2710       my_friendly_assert (IS_AGGR_TYPE (type)
2711                           || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2712
2713
2714       if (processing_template_decl)
2715         {
2716           /* This may change after the call to
2717              push_template_decl_real, but we want the original value.  */
2718           tree name = DECL_NAME (decl);
2719
2720           decl = push_template_decl_real (decl, globalize);
2721           /* If the current binding level is the binding level for the
2722              template parameters (see the comment in
2723              begin_template_parm_list) and the enclosing level is a class
2724              scope, and we're not looking at a friend, push the
2725              declaration of the member class into the class scope.  In the
2726              friend case, push_template_decl will already have put the
2727              friend into global scope, if appropriate.  */
2728           if (TREE_CODE (type) != ENUMERAL_TYPE
2729               && !globalize && b->template_parms_p
2730               && b->level_chain->parm_flag == 2)
2731             {
2732               finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2733               /* Put this tag on the list of tags for the class, since
2734                  that won't happen below because B is not the class
2735                  binding level, but is instead the pseudo-global level.  */
2736               b->level_chain->tags =
2737                 tree_cons (name, type, b->level_chain->tags);
2738               if (!COMPLETE_TYPE_P (current_class_type))
2739                 CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2740             }
2741         }
2742     }
2743
2744   return decl;
2745 }
2746
2747 /* In C++, you don't have to write `struct S' to refer to `S'; you
2748    can just use `S'.  We accomplish this by creating a TYPE_DECL as
2749    if the user had written `typedef struct S S'.  Create and return
2750    the TYPE_DECL for TYPE.  */
2751
2752 tree
2753 create_implicit_typedef (name, type)
2754      tree name;
2755      tree type;
2756 {
2757   tree decl;
2758
2759   decl = build_decl (TYPE_DECL, name, type);
2760   DECL_ARTIFICIAL (decl) = 1;
2761   /* There are other implicit type declarations, like the one *within*
2762      a class that allows you to write `S::S'.  We must distinguish
2763      amongst these.  */
2764   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2765   TYPE_NAME (type) = decl;
2766
2767   return decl;
2768 }
2769
2770 /* Remember a local name for name-mangling purposes.  */
2771
2772 static void
2773 push_local_name (decl)
2774      tree decl;
2775 {
2776   size_t i, nelts;
2777   tree t, name;
2778
2779   if (!local_names)
2780     VARRAY_TREE_INIT (local_names, 8, "local_names");
2781
2782   name = DECL_NAME (decl);
2783
2784   nelts = VARRAY_ACTIVE_SIZE (local_names);
2785   for (i = 0; i < nelts; i++)
2786     {
2787       t = VARRAY_TREE (local_names, i);
2788       if (DECL_NAME (t) == name)
2789         {
2790           if (!DECL_LANG_SPECIFIC (decl))
2791             retrofit_lang_decl (decl);
2792           if (DECL_LANG_SPECIFIC (t))
2793             DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1;
2794           else
2795             DECL_DISCRIMINATOR (decl) = 1;
2796
2797           VARRAY_TREE (local_names, i) = decl;
2798           return;
2799         }
2800     }
2801
2802   VARRAY_PUSH_TREE (local_names, decl);
2803 }
2804
2805 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2806    Normally put it into the inner-most non-tag-transparent scope,
2807    but if GLOBALIZE is true, put it in the inner-most non-class scope.
2808    The latter is needed for implicit declarations.  */
2809
2810 void
2811 pushtag (name, type, globalize)
2812      tree name, type;
2813      int globalize;
2814 {
2815   register struct binding_level *b;
2816
2817   b = current_binding_level;
2818   while (b->tag_transparent
2819          || (b->parm_flag == 2
2820              && (globalize
2821                  /* We may be defining a new type in the initializer
2822                     of a static member variable. We allow this when
2823                     not pedantic, and it is particularly useful for
2824                     type punning via an anonymous union. */
2825                  || COMPLETE_TYPE_P (b->this_class))))
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           /* FIXME what if it gets a name from typedef?  */
2884           if (ANON_AGGRNAME_P (name))
2885             DECL_IGNORED_P (d) = 1;
2886
2887           TYPE_CONTEXT (type) = DECL_CONTEXT (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 (b->parm_flag == 2)
2900         {
2901           if (!COMPLETE_TYPE_P (current_class_type))
2902             CLASSTYPE_TAGS (current_class_type) = b->tags;
2903         }
2904     }
2905
2906   if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2907     /* Use the canonical TYPE_DECL for this node.  */
2908     TYPE_STUB_DECL (type) = TYPE_NAME (type);
2909   else
2910     {
2911       /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2912          will be the tagged type we just added to the current
2913          binding level.  This fake NULL-named TYPE_DECL node helps
2914          dwarfout.c to know when it needs to output a
2915          representation of a tagged type, and it also gives us a
2916          convenient place to record the "scope start" address for
2917          the tagged type.  */
2918
2919       tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2920       TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2921     }
2922 }
2923
2924 /* Counter used to create anonymous type names.  */
2925
2926 static int anon_cnt = 0;
2927
2928 /* Return an IDENTIFIER which can be used as a name for
2929    anonymous structs and unions.  */
2930
2931 tree
2932 make_anon_name ()
2933 {
2934   char buf[32];
2935
2936   sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2937   return get_identifier (buf);
2938 }
2939
2940 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2941    This keeps dbxout from getting confused.  */
2942
2943 void
2944 clear_anon_tags ()
2945 {
2946   register struct binding_level *b;
2947   register tree tags;
2948   static int last_cnt = 0;
2949
2950   /* Fast out if no new anon names were declared.  */
2951   if (last_cnt == anon_cnt)
2952     return;
2953
2954   b = current_binding_level;
2955   while (b->tag_transparent)
2956     b = b->level_chain;
2957   tags = b->tags;
2958   while (tags)
2959     {
2960       /* A NULL purpose means we have already processed all tags
2961          from here to the end of the list.  */
2962       if (TREE_PURPOSE (tags) == NULL_TREE)
2963         break;
2964       if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2965         TREE_PURPOSE (tags) = NULL_TREE;
2966       tags = TREE_CHAIN (tags);
2967     }
2968   last_cnt = anon_cnt;
2969 }
2970 \f
2971 /* Subroutine of duplicate_decls: return truthvalue of whether
2972    or not types of these decls match.
2973
2974    For C++, we must compare the parameter list so that `int' can match
2975    `int&' in a parameter position, but `int&' is not confused with
2976    `const int&'.  */
2977
2978 int
2979 decls_match (newdecl, olddecl)
2980      tree newdecl, olddecl;
2981 {
2982   int types_match;
2983
2984   if (newdecl == olddecl)
2985     return 1;
2986
2987   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
2988     /* If the two DECLs are not even the same kind of thing, we're not
2989        interested in their types.  */
2990     return 0;
2991
2992   if (TREE_CODE (newdecl) == FUNCTION_DECL)
2993     {
2994       tree f1 = TREE_TYPE (newdecl);
2995       tree f2 = TREE_TYPE (olddecl);
2996       tree p1 = TYPE_ARG_TYPES (f1);
2997       tree p2 = TYPE_ARG_TYPES (f2);
2998
2999       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
3000           && ! (DECL_EXTERN_C_P (newdecl)
3001                 && DECL_EXTERN_C_P (olddecl)))
3002         return 0;
3003
3004       if (TREE_CODE (f1) != TREE_CODE (f2))
3005         return 0;
3006
3007       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
3008         {
3009           if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
3010               && (DECL_BUILT_IN (olddecl)
3011 #ifndef NO_IMPLICIT_EXTERN_C
3012                   || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
3013                   || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
3014 #endif
3015               ))
3016             {
3017               types_match = self_promoting_args_p (p1);
3018               if (p1 == void_list_node)
3019                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
3020             }
3021 #ifndef NO_IMPLICIT_EXTERN_C
3022           else if (p1 == NULL_TREE
3023                    && (DECL_EXTERN_C_P (olddecl)
3024                        && DECL_IN_SYSTEM_HEADER (olddecl)
3025                        && !DECL_CLASS_SCOPE_P (olddecl))
3026                    && (DECL_EXTERN_C_P (newdecl)
3027                        && DECL_IN_SYSTEM_HEADER (newdecl)
3028                        && !DECL_CLASS_SCOPE_P (newdecl)))
3029             {
3030               types_match = self_promoting_args_p (p2);
3031               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
3032             }
3033 #endif
3034           else
3035             types_match = compparms (p1, p2);
3036         }
3037       else
3038         types_match = 0;
3039     }
3040   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3041     {
3042       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3043                                 DECL_TEMPLATE_PARMS (olddecl)))
3044         return 0;
3045
3046       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
3047           != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
3048         return 0;
3049
3050       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3051         types_match = 1;
3052       else
3053         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
3054                                    DECL_TEMPLATE_RESULT (newdecl));
3055     }
3056   else
3057     {
3058       if (TREE_TYPE (newdecl) == error_mark_node)
3059         types_match = TREE_TYPE (olddecl) == error_mark_node;
3060       else if (TREE_TYPE (olddecl) == NULL_TREE)
3061         types_match = TREE_TYPE (newdecl) == NULL_TREE;
3062       else if (TREE_TYPE (newdecl) == NULL_TREE)
3063         types_match = 0;
3064       else
3065         types_match = comptypes (TREE_TYPE (newdecl),
3066                                  TREE_TYPE (olddecl),
3067                                  COMPARE_REDECLARATION);
3068     }
3069
3070   return types_match;
3071 }
3072
3073 /* If NEWDECL is `static' and an `extern' was seen previously,
3074    warn about it.  OLDDECL is the previous declaration.
3075
3076    Note that this does not apply to the C++ case of declaring
3077    a variable `extern const' and then later `const'.
3078
3079    Don't complain about built-in functions, since they are beyond
3080    the user's control.  */
3081
3082 static void
3083 warn_extern_redeclared_static (newdecl, olddecl)
3084      tree newdecl, olddecl;
3085 {
3086   static const char *explicit_extern_static_warning
3087     = "`%D' was declared `extern' and later `static'";
3088   static const char *implicit_extern_static_warning
3089     = "`%D' was declared implicitly `extern' and later `static'";
3090
3091   tree name;
3092
3093   if (TREE_CODE (newdecl) == TYPE_DECL
3094       || TREE_CODE (newdecl) == TEMPLATE_DECL
3095       || TREE_CODE (newdecl) == CONST_DECL)
3096     return;
3097
3098   /* Don't get confused by static member functions; that's a different
3099      use of `static'.  */
3100   if (TREE_CODE (newdecl) == FUNCTION_DECL
3101       && DECL_STATIC_FUNCTION_P (newdecl))
3102     return;
3103
3104   /* If the old declaration was `static', or the new one isn't, then
3105      then everything is OK.  */
3106   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
3107     return;
3108
3109   /* It's OK to declare a builtin function as `static'.  */
3110   if (TREE_CODE (olddecl) == FUNCTION_DECL
3111       && DECL_ARTIFICIAL (olddecl))
3112     return;
3113
3114   name = DECL_ASSEMBLER_NAME (newdecl);
3115   cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
3116               ? implicit_extern_static_warning
3117               : explicit_extern_static_warning, newdecl);
3118   cp_pedwarn_at ("previous declaration of `%D'", olddecl);
3119 }
3120
3121 /* Handle when a new declaration NEWDECL has the same name as an old
3122    one OLDDECL in the same binding contour.  Prints an error message
3123    if appropriate.
3124
3125    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
3126    Otherwise, return 0.  */
3127
3128 int
3129 duplicate_decls (newdecl, olddecl)
3130      tree newdecl, olddecl;
3131 {
3132   unsigned olddecl_uid = DECL_UID (olddecl);
3133   int olddecl_friend = 0, types_match = 0;
3134   int new_defines_function = 0;
3135
3136   if (newdecl == olddecl)
3137     return 1;
3138
3139   types_match = decls_match (newdecl, olddecl);
3140
3141   /* If either the type of the new decl or the type of the old decl is an
3142      error_mark_node, then that implies that we have already issued an
3143      error (earlier) for some bogus type specification, and in that case,
3144      it is rather pointless to harass the user with yet more error message
3145      about the same declaration, so just pretend the types match here.  */
3146   if (TREE_TYPE (newdecl) == error_mark_node
3147       || TREE_TYPE (olddecl) == error_mark_node)
3148     types_match = 1;
3149
3150   /* Check for redeclaration and other discrepancies. */
3151   if (TREE_CODE (olddecl) == FUNCTION_DECL
3152       && DECL_ARTIFICIAL (olddecl))
3153     {
3154       if (TREE_CODE (newdecl) != FUNCTION_DECL)
3155         {
3156           /* If you declare a built-in or predefined function name as static,
3157              the old definition is overridden, but optionally warn this was a
3158              bad choice of name.  */
3159           if (! TREE_PUBLIC (newdecl))
3160             {
3161               if (warn_shadow)
3162                 cp_warning ("shadowing %s function `%#D'",
3163                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3164                             olddecl);
3165               /* Discard the old built-in function.  */
3166               return 0;
3167             }
3168           /* If the built-in is not ansi, then programs can override
3169              it even globally without an error.  */
3170           else if (! DECL_BUILT_IN (olddecl))
3171             cp_warning ("library function `%#D' redeclared as non-function `%#D'",
3172                         olddecl, newdecl);
3173           else
3174             {
3175               cp_error ("declaration of `%#D'", newdecl);
3176               cp_error ("conflicts with built-in declaration `%#D'",
3177                         olddecl);
3178             }
3179           return 0;
3180         }
3181       else if (!types_match)
3182         {
3183           if ((DECL_EXTERN_C_P (newdecl)
3184                && DECL_EXTERN_C_P (olddecl))
3185               || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3186                             TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3187             {
3188               /* A near match; override the builtin.  */
3189
3190               if (TREE_PUBLIC (newdecl))
3191                 {
3192                   cp_warning ("new declaration `%#D'", newdecl);
3193                   cp_warning ("ambiguates built-in declaration `%#D'",
3194                               olddecl);
3195                 }
3196               else if (warn_shadow)
3197                 cp_warning ("shadowing %s function `%#D'",
3198                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3199                             olddecl);
3200             }
3201           else
3202             /* Discard the old built-in function.  */
3203             return 0;
3204         }
3205
3206       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3207         {
3208           /* If a builtin function is redeclared as `static', merge
3209              the declarations, but make the original one static.  */
3210           DECL_THIS_STATIC (olddecl) = 1;
3211           TREE_PUBLIC (olddecl) = 0;
3212
3213           /* Make the old declaration consistent with the new one so
3214              that all remnants of the builtin-ness of this function
3215              will be banished.  */
3216           SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
3217           SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
3218           COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
3219           SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (newdecl),
3220                                        newdecl);
3221         }
3222     }
3223   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3224     {
3225       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3226            && TREE_CODE (newdecl) != TYPE_DECL
3227            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3228                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3229           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3230               && TREE_CODE (olddecl) != TYPE_DECL
3231               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3232                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3233                         == TYPE_DECL))))
3234         {
3235           /* We do nothing special here, because C++ does such nasty
3236              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
3237              get shadowed, and know that if we need to find a TYPE_DECL
3238              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3239              slot of the identifier.  */
3240           return 0;
3241         }
3242
3243       if ((TREE_CODE (newdecl) == FUNCTION_DECL
3244            && DECL_FUNCTION_TEMPLATE_P (olddecl))
3245           || (TREE_CODE (olddecl) == FUNCTION_DECL
3246               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3247         return 0;
3248
3249       cp_error ("`%#D' redeclared as different kind of symbol", newdecl);
3250       if (TREE_CODE (olddecl) == TREE_LIST)
3251         olddecl = TREE_VALUE (olddecl);
3252       cp_error_at ("previous declaration of `%#D'", olddecl);
3253
3254       /* New decl is completely inconsistent with the old one =>
3255          tell caller to replace the old one.  */
3256
3257       return 0;
3258     }
3259   else if (!types_match)
3260     {
3261       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
3262         /* These are certainly not duplicate declarations; they're
3263            from different scopes.  */
3264         return 0;
3265
3266       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3267         {
3268           /* The name of a class template may not be declared to refer to
3269              any other template, class, function, object, namespace, value,
3270              or type in the same scope.  */
3271           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3272               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3273             {
3274               cp_error ("declaration of template `%#D'", newdecl);
3275               cp_error_at ("conflicts with previous declaration `%#D'",
3276                            olddecl);
3277             }
3278           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3279                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3280                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3281                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3282                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3283                                            DECL_TEMPLATE_PARMS (olddecl)))
3284             {
3285               cp_error ("new declaration `%#D'", newdecl);
3286               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3287             }
3288           return 0;
3289         }
3290       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3291         {
3292           if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
3293             {
3294               cp_error ("declaration of C function `%#D' conflicts with",
3295                         newdecl);
3296               cp_error_at ("previous declaration `%#D' here", olddecl);
3297             }
3298           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3299                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3300             {
3301               cp_error ("new declaration `%#D'", newdecl);
3302               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3303             }
3304           else
3305             return 0;
3306         }
3307
3308       /* Already complained about this, so don't do so again.  */
3309       else if (current_class_type == NULL_TREE
3310           || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3311         {
3312           cp_error ("conflicting types for `%#D'", newdecl);
3313           cp_error_at ("previous declaration as `%#D'", olddecl);
3314         }
3315     }
3316   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3317             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3318                  && (!DECL_TEMPLATE_INFO (newdecl)
3319                      || (DECL_TI_TEMPLATE (newdecl)
3320                          != DECL_TI_TEMPLATE (olddecl))))
3321                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3322                     && (!DECL_TEMPLATE_INFO (olddecl)
3323                         || (DECL_TI_TEMPLATE (olddecl)
3324                             != DECL_TI_TEMPLATE (newdecl))))))
3325     /* It's OK to have a template specialization and a non-template
3326        with the same type, or to have specializations of two
3327        different templates with the same type.  Note that if one is a
3328        specialization, and the other is an instantiation of the same
3329        template, that we do not exit at this point.  That situation
3330        can occur if we instantiate a template class, and then
3331        specialize one of its methods.  This situation is legal, but
3332        the declarations must be merged in the usual way.  */
3333     return 0;
3334   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3335            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3336                 && !DECL_USE_TEMPLATE (newdecl))
3337                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3338                    && !DECL_USE_TEMPLATE (olddecl))))
3339     /* One of the declarations is a template instantiation, and the
3340        other is not a template at all.  That's OK.  */
3341     return 0;
3342   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3343            && DECL_NAMESPACE_ALIAS (newdecl)
3344            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3345     /* Redeclaration of namespace alias, ignore it. */
3346     return 1;
3347   else
3348     {
3349       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3350       if (errmsg)
3351         {
3352           cp_error (errmsg, newdecl);
3353           if (DECL_NAME (olddecl) != NULL_TREE)
3354             cp_error_at ((DECL_INITIAL (olddecl)
3355                           && namespace_bindings_p ())
3356                          ? "`%#D' previously defined here"
3357                          : "`%#D' previously declared here", olddecl);
3358         }
3359       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3360                && DECL_INITIAL (olddecl) != NULL_TREE
3361                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3362                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3363         {
3364           /* Prototype decl follows defn w/o prototype.  */
3365           cp_warning_at ("prototype for `%#D'", newdecl);
3366           cp_warning_at ("follows non-prototype definition here", olddecl);
3367         }
3368       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3369                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3370         {
3371           /* extern "C" int foo ();
3372              int foo () { bar (); }
3373              is OK.  */
3374           if (current_lang_stack
3375               == &VARRAY_TREE (current_lang_base, 0))
3376             SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
3377           else
3378             {
3379               cp_error_at ("previous declaration of `%#D' with %L linkage",
3380                            olddecl, DECL_LANGUAGE (olddecl));
3381               cp_error ("conflicts with new declaration with %L linkage",
3382                         DECL_LANGUAGE (newdecl));
3383             }
3384         }
3385
3386       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3387         ;
3388       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3389         {
3390           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3391           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3392           int i = 1;
3393
3394           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3395             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3396
3397           for (; t1 && t1 != void_list_node;
3398                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3399             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3400               {
3401                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3402                                            TREE_PURPOSE (t2)))
3403                   {
3404                     if (pedantic)
3405                       {
3406                         cp_pedwarn ("default argument given for parameter %d of `%#D'",
3407                                     i, newdecl);
3408                         cp_pedwarn_at ("after previous specification in `%#D'",
3409                                        olddecl);
3410                       }
3411                   }
3412                 else
3413                   {
3414                     cp_error ("default argument given for parameter %d of `%#D'",
3415                               i, newdecl);
3416                     cp_error_at ("after previous specification in `%#D'",
3417                                  olddecl);
3418                   }
3419               }
3420
3421           if (DECL_DECLARED_INLINE_P (newdecl)
3422               && ! DECL_DECLARED_INLINE_P (olddecl)
3423               && TREE_ADDRESSABLE (olddecl) && warn_inline)
3424             {
3425               cp_warning ("`%#D' was used before it was declared inline",
3426                           newdecl);
3427               cp_warning_at ("previous non-inline declaration here",
3428                              olddecl);
3429             }
3430         }
3431     }
3432
3433   /* If new decl is `static' and an `extern' was seen previously,
3434      warn about it.  */
3435   warn_extern_redeclared_static (newdecl, olddecl);
3436
3437   /* We have committed to returning 1 at this point.  */
3438   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3439     {
3440       /* Now that functions must hold information normally held
3441          by field decls, there is extra work to do so that
3442          declaration information does not get destroyed during
3443          definition.  */
3444       if (DECL_VINDEX (olddecl))
3445         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3446       if (DECL_VIRTUAL_CONTEXT (olddecl))
3447         DECL_VIRTUAL_CONTEXT (newdecl) = DECL_VIRTUAL_CONTEXT (olddecl);
3448       if (DECL_CONTEXT (olddecl))
3449         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3450       if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
3451         DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3452       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3453       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3454       DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3455       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3456       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3457       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3458       if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK)
3459         SET_OVERLOADED_OPERATOR_CODE
3460           (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl));
3461       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3462
3463       /* Optionally warn about more than one declaration for the same
3464          name, but don't warn about a function declaration followed by a
3465          definition.  */
3466       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3467           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3468           /* Don't warn about extern decl followed by definition. */
3469           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3470           /* Don't warn about friends, let add_friend take care of it. */
3471           && ! DECL_FRIEND_P (newdecl))
3472         {
3473           cp_warning ("redundant redeclaration of `%D' in same scope", newdecl);
3474           cp_warning_at ("previous declaration of `%D'", olddecl);
3475         }
3476     }
3477
3478   /* Deal with C++: must preserve virtual function table size.  */
3479   if (TREE_CODE (olddecl) == TYPE_DECL)
3480     {
3481       register tree newtype = TREE_TYPE (newdecl);
3482       register tree oldtype = TREE_TYPE (olddecl);
3483
3484       if (newtype != error_mark_node && oldtype != error_mark_node
3485           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3486         {
3487           CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
3488           CLASSTYPE_FRIEND_CLASSES (newtype)
3489             = CLASSTYPE_FRIEND_CLASSES (oldtype);
3490         }
3491
3492       DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
3493     }
3494
3495   /* Copy all the DECL_... slots specified in the new decl
3496      except for any that we copy here from the old type.  */
3497   DECL_MACHINE_ATTRIBUTES (newdecl)
3498     = merge_machine_decl_attributes (olddecl, newdecl);
3499
3500   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3501     {
3502       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3503       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3504         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3505                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3506
3507       /* If the new declaration is a definition, update the file and
3508          line information on the declaration.  */
3509       if (DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)) == NULL_TREE
3510           && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl)) != NULL_TREE)
3511         {
3512           DECL_SOURCE_LINE (olddecl)
3513             = DECL_SOURCE_LINE (DECL_TEMPLATE_RESULT (olddecl))
3514             = DECL_SOURCE_LINE (newdecl);
3515           DECL_SOURCE_FILE (olddecl)
3516             = DECL_SOURCE_FILE (DECL_TEMPLATE_RESULT (olddecl))
3517             = DECL_SOURCE_FILE (newdecl);
3518         }
3519
3520       return 1;
3521     }
3522
3523   if (types_match)
3524     {
3525       /* Automatically handles default parameters.  */
3526       tree oldtype = TREE_TYPE (olddecl);
3527       tree newtype;
3528
3529       /* Merge the data types specified in the two decls.  */
3530       newtype = common_type (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3531
3532       /* If common_type produces a non-typedef type, just use the old type.  */
3533       if (TREE_CODE (newdecl) == TYPE_DECL
3534           && newtype == DECL_ORIGINAL_TYPE (newdecl))
3535         newtype = oldtype;
3536
3537       if (TREE_CODE (newdecl) == VAR_DECL)
3538         DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3539       /* Do this after calling `common_type' so that default
3540          parameters don't confuse us.  */
3541       else if (TREE_CODE (newdecl) == FUNCTION_DECL
3542           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3543               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3544         {
3545           TREE_TYPE (newdecl) = build_exception_variant (newtype,
3546                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3547           TREE_TYPE (olddecl) = build_exception_variant (newtype,
3548                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
3549
3550           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3551               && DECL_SOURCE_LINE (olddecl) != 0
3552               && flag_exceptions
3553               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3554                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3555             {
3556               cp_error ("declaration of `%F' throws different exceptions",
3557                         newdecl);
3558               cp_error_at ("than previous declaration `%F'", olddecl);
3559             }
3560         }
3561       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3562
3563       /* Lay the type out, unless already done.  */
3564       if (! same_type_p (newtype, oldtype)
3565           && TREE_TYPE (newdecl) != error_mark_node
3566           && !(processing_template_decl && uses_template_parms (newdecl)))
3567         layout_type (TREE_TYPE (newdecl));
3568
3569       if ((TREE_CODE (newdecl) == VAR_DECL
3570            || TREE_CODE (newdecl) == PARM_DECL
3571            || TREE_CODE (newdecl) == RESULT_DECL
3572            || TREE_CODE (newdecl) == FIELD_DECL
3573            || TREE_CODE (newdecl) == TYPE_DECL)
3574           && !(processing_template_decl && uses_template_parms (newdecl)))
3575         layout_decl (newdecl, 0);
3576
3577       /* Merge the type qualifiers.  */
3578       if (TREE_READONLY (newdecl))
3579         TREE_READONLY (olddecl) = 1;
3580       if (TREE_THIS_VOLATILE (newdecl))
3581         TREE_THIS_VOLATILE (olddecl) = 1;
3582
3583       /* Merge the initialization information.  */
3584       if (DECL_INITIAL (newdecl) == NULL_TREE
3585           && DECL_INITIAL (olddecl) != NULL_TREE)
3586         {
3587           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3588           DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
3589           DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
3590           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3591               && DECL_LANG_SPECIFIC (newdecl)
3592               && DECL_LANG_SPECIFIC (olddecl))
3593             DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3594         }
3595
3596       /* Merge the section attribute.
3597          We want to issue an error if the sections conflict but that must be
3598          done later in decl_attributes since we are called before attributes
3599          are assigned.  */
3600       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3601         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3602
3603       /* Keep the old rtl since we can safely use it.  */
3604       COPY_DECL_RTL (olddecl, newdecl);
3605
3606       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3607         {
3608           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3609             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3610           DECL_NO_CHECK_MEMORY_USAGE (newdecl)
3611             |= DECL_NO_CHECK_MEMORY_USAGE (olddecl);
3612           DECL_NO_LIMIT_STACK (newdecl)
3613             |= DECL_NO_LIMIT_STACK (olddecl);
3614         }
3615     }
3616   /* If cannot merge, then use the new type and qualifiers,
3617      and don't preserve the old rtl.  */
3618   else
3619     {
3620       /* Clean out any memory we had of the old declaration.  */
3621       tree oldstatic = value_member (olddecl, static_aggregates);
3622       if (oldstatic)
3623         TREE_VALUE (oldstatic) = error_mark_node;
3624
3625       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3626       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3627       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3628       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3629     }
3630
3631   /* Merge the storage class information.  */
3632   DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
3633   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3634   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3635   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3636   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3637   if (! DECL_EXTERNAL (olddecl))
3638     DECL_EXTERNAL (newdecl) = 0;
3639
3640   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3641     {
3642       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3643       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3644       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3645       DECL_TEMPLATE_INSTANTIATED (newdecl)
3646         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3647       /* Don't really know how much of the language-specific
3648          values we should copy from old to new.  */
3649       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3650       DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
3651       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3652       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3653       DECL_INITIALIZED_IN_CLASS_P (newdecl)
3654         |= DECL_INITIALIZED_IN_CLASS_P (olddecl);
3655       olddecl_friend = DECL_FRIEND_P (olddecl);
3656
3657       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
3658       if (TREE_CODE (newdecl) == FUNCTION_DECL
3659           || DECL_FUNCTION_TEMPLATE_P (newdecl))
3660         DECL_BEFRIENDING_CLASSES (newdecl)
3661           = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3662                      DECL_BEFRIENDING_CLASSES (olddecl));
3663     }
3664
3665   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3666     {
3667       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3668           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3669         {
3670           /* If newdecl is not a specialization, then it is not a
3671              template-related function at all.  And that means that we
3672              shoud have exited above, returning 0.  */
3673           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3674                               0);
3675
3676           if (TREE_USED (olddecl))
3677             /* From [temp.expl.spec]:
3678
3679                If a template, a member template or the member of a class
3680                template is explicitly specialized then that
3681                specialization shall be declared before the first use of
3682                that specialization that would cause an implicit
3683                instantiation to take place, in every translation unit in
3684                which such a use occurs.  */
3685             cp_error ("explicit specialization of %D after first use",
3686                       olddecl);
3687
3688           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3689         }
3690       DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl);
3691
3692       /* If either decl says `inline', this fn is inline, unless its
3693          definition was passed already.  */
3694       if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3695         DECL_INLINE (olddecl) = 1;
3696       DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3697
3698       /* Preserve abstractness on cloned [cd]tors.  */
3699       DECL_ABSTRACT (newdecl) = DECL_ABSTRACT (olddecl);
3700
3701       if (! types_match)
3702         {
3703           SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
3704           COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl);
3705           SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
3706         }
3707       if (! types_match || new_defines_function)
3708         {
3709           /* These need to be copied so that the names are available.
3710              Note that if the types do match, we'll preserve inline
3711              info and other bits, but if not, we won't.  */
3712           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3713           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3714         }
3715       if (new_defines_function)
3716         /* If defining a function declared with other language
3717            linkage, use the previously declared language linkage.  */
3718         SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
3719       else if (types_match)
3720         {
3721           /* If redeclaring a builtin function, and not a definition,
3722              it stays built in.  */
3723           if (DECL_BUILT_IN (olddecl))
3724             {
3725               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3726               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3727               /* If we're keeping the built-in definition, keep the rtl,
3728                  regardless of declaration matches.  */
3729               SET_DECL_RTL (newdecl, DECL_RTL (olddecl));
3730             }
3731           else
3732             DECL_NUM_STMTS (newdecl) = DECL_NUM_STMTS (olddecl);
3733
3734           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3735           if ((DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl)))
3736             /* Previously saved insns go together with
3737                the function's previous definition.  */
3738             DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3739           /* Don't clear out the arguments if we're redefining a function.  */
3740           if (DECL_ARGUMENTS (olddecl))
3741             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3742         }
3743     }
3744   else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3745     NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3746
3747   /* Now preserve various other info from the definition.  */
3748   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3749   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3750   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3751   COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
3752
3753   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3754     {
3755       int function_size;
3756
3757       function_size = sizeof (struct tree_decl);
3758
3759       bcopy ((char *) newdecl + sizeof (struct tree_common),
3760              (char *) olddecl + sizeof (struct tree_common),
3761              function_size - sizeof (struct tree_common));
3762
3763       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3764         {
3765           /* If newdecl is a template instantiation, it is possible that
3766              the following sequence of events has occurred:
3767
3768              o A friend function was declared in a class template.  The
3769              class template was instantiated.
3770
3771              o The instantiation of the friend declaration was
3772              recorded on the instantiation list, and is newdecl.
3773
3774              o Later, however, instantiate_class_template called pushdecl
3775              on the newdecl to perform name injection.  But, pushdecl in
3776              turn called duplicate_decls when it discovered that another
3777              declaration of a global function with the same name already
3778              existed.
3779
3780              o Here, in duplicate_decls, we decided to clobber newdecl.
3781
3782              If we're going to do that, we'd better make sure that
3783              olddecl, and not newdecl, is on the list of
3784              instantiations so that if we try to do the instantiation
3785              again we won't get the clobbered declaration.  */
3786
3787           tree tmpl = DECL_TI_TEMPLATE (newdecl);
3788           tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3789
3790           for (; decls; decls = TREE_CHAIN (decls))
3791             if (TREE_VALUE (decls) == newdecl)
3792               TREE_VALUE (decls) = olddecl;
3793         }
3794     }
3795   else
3796     {
3797       bcopy ((char *) newdecl + sizeof (struct tree_common),
3798              (char *) olddecl + sizeof (struct tree_common),
3799              sizeof (struct tree_decl) - sizeof (struct tree_common)
3800              + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
3801     }
3802
3803   DECL_UID (olddecl) = olddecl_uid;
3804   if (olddecl_friend)
3805     DECL_FRIEND_P (olddecl) = 1;
3806
3807   /* NEWDECL contains the merged attribute lists.
3808      Update OLDDECL to be the same.  */
3809   DECL_MACHINE_ATTRIBUTES (olddecl) = DECL_MACHINE_ATTRIBUTES (newdecl);
3810
3811   return 1;
3812 }
3813
3814 /* Record a decl-node X as belonging to the current lexical scope.
3815    Check for errors (such as an incompatible declaration for the same
3816    name already seen in the same scope).
3817
3818    Returns either X or an old decl for the same name.
3819    If an old decl is returned, it may have been smashed
3820    to agree with what X says.  */
3821
3822 tree
3823 pushdecl (x)
3824      tree x;
3825 {
3826   register tree t;
3827   register tree name;
3828   int need_new_binding;
3829
3830   /* We shouldn't be calling pushdecl when we're generating RTL for a
3831      function that we already did semantic analysis on previously.  */
3832   my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3833                       19990913);
3834
3835   need_new_binding = 1;
3836
3837   if (DECL_TEMPLATE_PARM_P (x))
3838     /* Template parameters have no context; they are not X::T even
3839        when declared within a class or namespace.  */
3840     ;
3841   else
3842     {
3843       if (current_function_decl && x != current_function_decl
3844           /* A local declaration for a function doesn't constitute
3845              nesting.  */
3846           && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3847           /* A local declaration for an `extern' variable is in the
3848              scope of the current namespace, not the current
3849              function.  */
3850           && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3851           && !DECL_CONTEXT (x))
3852         DECL_CONTEXT (x) = current_function_decl;
3853
3854       /* If this is the declaration for a namespace-scope function,
3855          but the declaration itself is in a local scope, mark the
3856          declaration.  */
3857       if (TREE_CODE (x) == FUNCTION_DECL
3858           && DECL_NAMESPACE_SCOPE_P (x)
3859           && current_function_decl
3860           && x != current_function_decl)
3861         DECL_LOCAL_FUNCTION_P (x) = 1;
3862     }
3863
3864   name = DECL_NAME (x);
3865   if (name)
3866     {
3867       int different_binding_level = 0;
3868
3869       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3870         name = TREE_OPERAND (name, 0);
3871
3872       /* In case this decl was explicitly namespace-qualified, look it
3873          up in its namespace context.  */
3874       if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x)
3875           && namespace_bindings_p ())
3876         t = namespace_binding (name, DECL_CONTEXT (x));
3877       else
3878         t = lookup_name_current_level (name);
3879
3880       /* [basic.link] If there is a visible declaration of an entity
3881          with linkage having the same name and type, ignoring entities
3882          declared outside the innermost enclosing namespace scope, the
3883          block scope declaration declares that same entity and
3884          receives the linkage of the previous declaration.  */
3885       if (! t && current_function_decl && x != current_function_decl
3886           && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
3887           && DECL_EXTERNAL (x))
3888         {
3889           /* Look in block scope.  */
3890           t = IDENTIFIER_VALUE (name);
3891           /* Or in the innermost namespace.  */
3892           if (! t)
3893             t = namespace_binding (name, DECL_CONTEXT (x));
3894           /* Does it have linkage?  Note that if this isn't a DECL, it's an
3895              OVERLOAD, which is OK.  */
3896           if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
3897             t = NULL_TREE;
3898           if (t)
3899             different_binding_level = 1;
3900         }
3901
3902       /* If we are declaring a function, and the result of name-lookup
3903          was an OVERLOAD, look for an overloaded instance that is
3904          actually the same as the function we are declaring.  (If
3905          there is one, we have to merge our declaration with the
3906          previous declaration.)  */
3907       if (t && TREE_CODE (t) == OVERLOAD)
3908         {
3909           tree match;
3910
3911           if (TREE_CODE (x) == FUNCTION_DECL)
3912             for (match = t; match; match = OVL_NEXT (match))
3913               {
3914                 if (decls_match (OVL_CURRENT (match), x))
3915                   break;
3916               }
3917           else
3918             /* Just choose one.  */
3919             match = t;
3920
3921           if (match)
3922             t = OVL_CURRENT (match);
3923           else
3924             t = NULL_TREE;
3925         }
3926
3927       if (t == error_mark_node)
3928         {
3929           /* error_mark_node is 0 for a while during initialization!  */
3930           t = NULL_TREE;
3931           cp_error_at ("`%#D' used prior to declaration", x);
3932         }
3933       else if (t != NULL_TREE)
3934         {
3935           if (different_binding_level)
3936             {
3937               if (decls_match (x, t))
3938                 /* The standard only says that the local extern
3939                    inherits linkage from the previous decl; in
3940                    particular, default args are not shared.  It would
3941                    be nice to propagate inlining info, though.  FIXME.  */
3942                 TREE_PUBLIC (x) = TREE_PUBLIC (t);
3943             }
3944           else if (TREE_CODE (t) == PARM_DECL)
3945             {
3946               if (DECL_CONTEXT (t) == NULL_TREE)
3947                 /* This is probaby caused by too many errors, but calling
3948                    abort will say that if errors have occurred.  */
3949                 abort ();
3950
3951               /* Check for duplicate params.  */
3952               if (duplicate_decls (x, t))
3953                 return t;
3954             }
3955           else if ((DECL_EXTERN_C_FUNCTION_P (x)
3956                     || DECL_FUNCTION_TEMPLATE_P (x))
3957                    && is_overloaded_fn (t))
3958             /* Don't do anything just yet. */;
3959           else if (t == wchar_decl_node)
3960             {
3961               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3962                 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x));
3963
3964               /* Throw away the redeclaration.  */
3965               return t;
3966             }
3967           else if (TREE_CODE (t) != TREE_CODE (x))
3968             {
3969               if (duplicate_decls (x, t))
3970                 return t;
3971             }
3972           else if (duplicate_decls (x, t))
3973             {
3974               if (TREE_CODE (t) == TYPE_DECL)
3975                 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3976               else if (TREE_CODE (t) == FUNCTION_DECL)
3977                 check_default_args (t);
3978
3979               return t;
3980             }
3981           else if (DECL_MAIN_P (x))
3982             {
3983               /* A redeclaration of main, but not a duplicate of the
3984                  previous one.
3985
3986                  [basic.start.main]
3987
3988                  This function shall not be overloaded.  */
3989               cp_error_at ("invalid redeclaration of `%D'", t);
3990               cp_error ("as `%D'", x);
3991               /* We don't try to push this declaration since that
3992                  causes a crash.  */
3993               return x;
3994             }
3995         }
3996
3997       check_template_shadow (x);
3998
3999       /* If this is a function conjured up by the backend, massage it
4000          so it looks friendly.  */
4001       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
4002         {
4003           retrofit_lang_decl (x);
4004           SET_DECL_LANGUAGE (x, lang_c);
4005         }
4006
4007       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
4008         {
4009           t = push_overloaded_decl (x, PUSH_LOCAL);
4010           if (t != x)
4011             return t;
4012           if (!namespace_bindings_p ())
4013             /* We do not need to create a binding for this name;
4014                push_overloaded_decl will have already done so if
4015                necessary.  */
4016             need_new_binding = 0;
4017         }
4018       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
4019         {
4020           t = push_overloaded_decl (x, PUSH_GLOBAL);
4021           if (t == x)
4022             add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
4023           return t;
4024         }
4025
4026       /* If declaring a type as a typedef, copy the type (unless we're
4027          at line 0), and install this TYPE_DECL as the new type's typedef
4028          name.  See the extensive comment in ../c-decl.c (pushdecl). */
4029       if (TREE_CODE (x) == TYPE_DECL)
4030         {
4031           tree type = TREE_TYPE (x);
4032           if (DECL_SOURCE_LINE (x) == 0)
4033             {
4034               if (TYPE_NAME (type) == 0)
4035                 TYPE_NAME (type) = x;
4036             }
4037           else if (type != error_mark_node && TYPE_NAME (type) != x
4038                    /* We don't want to copy the type when all we're
4039                       doing is making a TYPE_DECL for the purposes of
4040                       inlining.  */
4041                    && (!TYPE_NAME (type)
4042                        || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
4043             {
4044               DECL_ORIGINAL_TYPE (x) = type;
4045               type = build_type_copy (type);
4046               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
4047               TYPE_NAME (type) = x;
4048               TREE_TYPE (x) = type;
4049             }
4050
4051           if (type != error_mark_node
4052               && TYPE_NAME (type)
4053               && TYPE_IDENTIFIER (type))
4054             set_identifier_type_value_with_scope (DECL_NAME (x), type,
4055                                                   current_binding_level);
4056
4057         }
4058
4059       /* Multiple external decls of the same identifier ought to match.
4060
4061          We get warnings about inline functions where they are defined.
4062          We get warnings about other functions from push_overloaded_decl.
4063
4064          Avoid duplicate warnings where they are used.  */
4065       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
4066         {
4067           tree decl;
4068
4069           decl = IDENTIFIER_NAMESPACE_VALUE (name);
4070           if (decl && TREE_CODE (decl) == OVERLOAD)
4071             decl = OVL_FUNCTION (decl);
4072
4073           if (decl && decl != error_mark_node
4074               && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
4075               /* If different sort of thing, we already gave an error.  */
4076               && TREE_CODE (decl) == TREE_CODE (x)
4077               && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
4078             {
4079               cp_pedwarn ("type mismatch with previous external decl", x);
4080               cp_pedwarn_at ("previous external decl of `%#D'", decl);
4081             }
4082         }
4083
4084       /* This name is new in its binding level.
4085          Install the new declaration and return it.  */
4086       if (namespace_bindings_p ())
4087         {
4088           /* Install a global value.  */
4089
4090           /* If the first global decl has external linkage,
4091              warn if we later see static one.  */
4092           if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
4093             TREE_PUBLIC (name) = 1;
4094
4095           /* Bind the name for the entity.  */
4096           if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
4097                 && t != NULL_TREE)
4098               && (TREE_CODE (x) == TYPE_DECL
4099                   || TREE_CODE (x) == VAR_DECL
4100                   || TREE_CODE (x) == NAMESPACE_DECL
4101                   || TREE_CODE (x) == CONST_DECL
4102                   || TREE_CODE (x) == TEMPLATE_DECL))
4103             SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
4104
4105           /* Don't forget if the function was used via an implicit decl.  */
4106           if (IDENTIFIER_IMPLICIT_DECL (name)
4107               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
4108             TREE_USED (x) = 1;
4109
4110           /* Don't forget if its address was taken in that way.  */
4111           if (IDENTIFIER_IMPLICIT_DECL (name)
4112               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
4113             TREE_ADDRESSABLE (x) = 1;
4114
4115           /* Warn about mismatches against previous implicit decl.  */
4116           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
4117               /* If this real decl matches the implicit, don't complain.  */
4118               && ! (TREE_CODE (x) == FUNCTION_DECL
4119                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
4120             cp_warning
4121               ("`%D' was previously implicitly declared to return `int'", x);
4122
4123           /* If new decl is `static' and an `extern' was seen previously,
4124              warn about it.  */
4125           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
4126             warn_extern_redeclared_static (x, t);
4127         }
4128       else
4129         {
4130           /* Here to install a non-global value.  */
4131           tree oldlocal = IDENTIFIER_VALUE (name);
4132           tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
4133
4134           if (need_new_binding)
4135             {
4136               push_local_binding (name, x, 0);
4137               /* Because push_local_binding will hook X on to the
4138                  current_binding_level's name list, we don't want to
4139                  do that again below.  */
4140               need_new_binding = 0;
4141             }
4142
4143           /* If this is a TYPE_DECL, push it into the type value slot.  */
4144           if (TREE_CODE (x) == TYPE_DECL)
4145             set_identifier_type_value_with_scope (name, TREE_TYPE (x),
4146                                                   current_binding_level);
4147
4148           /* Clear out any TYPE_DECL shadowed by a namespace so that
4149              we won't think this is a type.  The C struct hack doesn't
4150              go through namespaces.  */
4151           if (TREE_CODE (x) == NAMESPACE_DECL)
4152             set_identifier_type_value_with_scope (name, NULL_TREE,
4153                                                   current_binding_level);
4154
4155           if (oldlocal)
4156             {
4157               tree d = oldlocal;
4158
4159               while (oldlocal
4160                      && TREE_CODE (oldlocal) == VAR_DECL
4161                      && DECL_DEAD_FOR_LOCAL (oldlocal))
4162                 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
4163
4164               if (oldlocal == NULL_TREE)
4165                 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
4166             }
4167
4168           /* If this is an extern function declaration, see if we
4169              have a global definition or declaration for the function.  */
4170           if (oldlocal == NULL_TREE
4171               && DECL_EXTERNAL (x)
4172               && oldglobal != NULL_TREE
4173               && TREE_CODE (x) == FUNCTION_DECL
4174               && TREE_CODE (oldglobal) == FUNCTION_DECL)
4175             {
4176               /* We have one.  Their types must agree.  */
4177               if (decls_match (x, oldglobal))
4178                 /* OK */;
4179               else
4180                 {
4181                   cp_warning ("extern declaration of `%#D' doesn't match", x);
4182                   cp_warning_at ("global declaration `%#D'", oldglobal);
4183                 }
4184             }
4185           /* If we have a local external declaration,
4186              and no file-scope declaration has yet been seen,
4187              then if we later have a file-scope decl it must not be static.  */
4188           if (oldlocal == NULL_TREE
4189               && oldglobal == NULL_TREE
4190               && DECL_EXTERNAL (x)
4191               && TREE_PUBLIC (x))
4192             TREE_PUBLIC (name) = 1;
4193
4194           /* Warn if shadowing an argument at the top level of the body.  */
4195           if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
4196               /* Inline decls shadow nothing.  */
4197               && !DECL_FROM_INLINE (x)
4198               && TREE_CODE (oldlocal) == PARM_DECL
4199               /* Don't complain if it's from an enclosing function.  */
4200               && DECL_CONTEXT (oldlocal) == current_function_decl
4201               && TREE_CODE (x) != PARM_DECL)
4202             {
4203               /* Go to where the parms should be and see if we
4204                  find them there.  */
4205               struct binding_level *b = current_binding_level->level_chain;
4206
4207               if (cleanup_label)
4208                 b = b->level_chain;
4209
4210               /* ARM $8.3 */
4211               if (b->parm_flag == 1)
4212                 cp_error ("declaration of `%#D' shadows a parameter", name);
4213             }
4214
4215           /* Maybe warn if shadowing something else.  */
4216           if (warn_shadow && !DECL_EXTERNAL (x)
4217               /* Inline decls shadow nothing.  */
4218               && !DECL_FROM_INLINE (x)
4219               /* No shadow warnings for internally generated vars.  */
4220               && ! DECL_ARTIFICIAL (x)
4221               /* No shadow warnings for vars made for inlining.  */
4222               && ! DECL_FROM_INLINE (x))
4223             {
4224               if (oldlocal != NULL_TREE && TREE_CODE (oldlocal) == PARM_DECL)
4225                 warning ("declaration of `%s' shadows a parameter",
4226                         IDENTIFIER_POINTER (name));
4227               else if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4228                        && current_class_ptr
4229                        && !TREE_STATIC (name))
4230                 warning ("declaration of `%s' shadows a member of `this'",
4231                         IDENTIFIER_POINTER (name));
4232               else if (oldlocal != NULL_TREE)
4233                 warning ("declaration of `%s' shadows previous local",
4234                         IDENTIFIER_POINTER (name));
4235               else if (oldglobal != NULL_TREE)
4236                 /* XXX shadow warnings in outer-more namespaces */
4237                 warning ("declaration of `%s' shadows global declaration",
4238                         IDENTIFIER_POINTER (name));
4239             }
4240         }
4241
4242       if (TREE_CODE (x) == FUNCTION_DECL)
4243         check_default_args (x);
4244
4245       /* Keep count of variables in this level with incomplete type.  */
4246       if (TREE_CODE (x) == VAR_DECL
4247           && TREE_TYPE (x) != error_mark_node
4248           && ((!COMPLETE_TYPE_P (TREE_TYPE (x))
4249                && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
4250               /* RTTI TD entries are created while defining the type_info.  */
4251               || (TYPE_LANG_SPECIFIC (TREE_TYPE (x))
4252                   && TYPE_BEING_DEFINED (TREE_TYPE (x)))))
4253         {
4254           if (namespace_bindings_p ())
4255             namespace_scope_incomplete
4256               = tree_cons (NULL_TREE, x, namespace_scope_incomplete);
4257           else
4258             current_binding_level->incomplete
4259               = tree_cons (NULL_TREE, x, current_binding_level->incomplete);
4260         }
4261     }
4262
4263   if (need_new_binding)
4264     add_decl_to_level (x,
4265                        DECL_NAMESPACE_SCOPE_P (x)
4266                        ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4267                        : current_binding_level);
4268
4269   return x;
4270 }
4271
4272 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
4273    caller to set DECL_CONTEXT properly.  */
4274
4275 static tree
4276 pushdecl_with_scope (x, level)
4277      tree x;
4278      struct binding_level *level;
4279 {
4280   register struct binding_level *b;
4281   tree function_decl = current_function_decl;
4282
4283   current_function_decl = NULL_TREE;
4284   if (level->parm_flag == 2)
4285     {
4286       b = class_binding_level;
4287       class_binding_level = level;
4288       pushdecl_class_level (x);
4289       class_binding_level = b;
4290     }
4291   else
4292     {
4293       b = current_binding_level;
4294       current_binding_level = level;
4295       x = pushdecl (x);
4296       current_binding_level = b;
4297     }
4298   current_function_decl = function_decl;
4299   return x;
4300 }
4301
4302 /* Like pushdecl, only it places X in the current namespace,
4303    if appropriate.  */
4304
4305 tree
4306 pushdecl_namespace_level (x)
4307      tree x;
4308 {
4309   register struct binding_level *b = current_binding_level;
4310   register tree t;
4311
4312   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4313
4314   /* Now, the type_shadowed stack may screw us.  Munge it so it does
4315      what we want.  */
4316   if (TREE_CODE (x) == TYPE_DECL)
4317     {
4318       tree name = DECL_NAME (x);
4319       tree newval;
4320       tree *ptr = (tree *)0;
4321       for (; b != global_binding_level; b = b->level_chain)
4322         {
4323           tree shadowed = b->type_shadowed;
4324           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4325             if (TREE_PURPOSE (shadowed) == name)
4326               {
4327                 ptr = &TREE_VALUE (shadowed);
4328                 /* Can't break out of the loop here because sometimes
4329                    a binding level will have duplicate bindings for
4330                    PT names.  It's gross, but I haven't time to fix it.  */
4331               }
4332         }
4333       newval = TREE_TYPE (x);
4334       if (ptr == (tree *)0)
4335         {
4336           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
4337              up here if this is changed to an assertion.  --KR  */
4338           SET_IDENTIFIER_TYPE_VALUE (name, newval);
4339         }
4340       else
4341         {
4342           *ptr = newval;
4343         }
4344     }
4345   return t;
4346 }
4347
4348 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4349    if appropriate.  */
4350
4351 tree
4352 pushdecl_top_level (x)
4353      tree x;
4354 {
4355   push_to_top_level ();
4356   x = pushdecl_namespace_level (x);
4357   pop_from_top_level ();
4358   return x;
4359 }
4360
4361 /* Make the declaration of X appear in CLASS scope.  */
4362
4363 void
4364 pushdecl_class_level (x)
4365      tree x;
4366 {
4367   /* Don't use DECL_ASSEMBLER_NAME here!  Everything that looks in class
4368      scope looks for the pre-mangled name.  */
4369   register tree name;
4370
4371   if (TREE_CODE (x) == OVERLOAD)
4372     x = OVL_CURRENT (x);
4373   name = DECL_NAME (x);
4374
4375   if (name)
4376     {
4377       push_class_level_binding (name, x);
4378       if (TREE_CODE (x) == TYPE_DECL)
4379         set_identifier_type_value (name, TREE_TYPE (x));
4380     }
4381   else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4382     {
4383       tree f;
4384
4385       for (f = TYPE_FIELDS (TREE_TYPE (x));
4386            f;
4387            f = TREE_CHAIN (f))
4388         pushdecl_class_level (f);
4389     }
4390 }
4391
4392 /* Enter DECL into the symbol table, if that's appropriate.  Returns
4393    DECL, or a modified version thereof.  */
4394
4395 tree
4396 maybe_push_decl (decl)
4397      tree decl;
4398 {
4399   tree type = TREE_TYPE (decl);
4400
4401   /* Add this decl to the current binding level, but not if it comes
4402      from another scope, e.g. a static member variable.  TEM may equal
4403      DECL or it may be a previous decl of the same name.  */
4404   if (decl == error_mark_node
4405       || (TREE_CODE (decl) != PARM_DECL
4406           && DECL_CONTEXT (decl) != NULL_TREE
4407           /* Definitions of namespace members outside their namespace are
4408              possible. */
4409           && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4410       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4411       || TREE_CODE (type) == UNKNOWN_TYPE
4412       /* The declaration of a template specialization does not affect
4413          the functions available for overload resolution, so we do not
4414          call pushdecl.  */
4415       || (TREE_CODE (decl) == FUNCTION_DECL
4416           && DECL_TEMPLATE_SPECIALIZATION (decl)))
4417     return decl;
4418   else
4419     return pushdecl (decl);
4420 }
4421
4422 /* Make the declaration(s) of X appear in CLASS scope
4423    under the name NAME.  */
4424
4425 void
4426 push_class_level_binding (name, x)
4427      tree name;
4428      tree x;
4429 {
4430   tree binding;
4431   /* The class_binding_level will be NULL if x is a template
4432      parameter name in a member template.  */
4433   if (!class_binding_level)
4434     return;
4435
4436   /* Make sure that this new member does not have the same name
4437      as a template parameter.  */
4438   if (TYPE_BEING_DEFINED (current_class_type))
4439     check_template_shadow (x);
4440
4441   /* If this declaration shadows a declaration from an enclosing
4442      class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4443      we leave this class.  Record the shadowed declaration here.  */
4444   binding = IDENTIFIER_BINDING (name);
4445   if (binding
4446       && ((TREE_CODE (x) == OVERLOAD
4447            && BINDING_VALUE (binding)
4448            && is_overloaded_fn (BINDING_VALUE (binding)))
4449           || INHERITED_VALUE_BINDING_P (binding)))
4450     {
4451       tree shadow;
4452       tree old_decl;
4453
4454       /* If the old binding was from a base class, and was for a tag
4455          name, slide it over to make room for the new binding.  The
4456          old binding is still visible if explicitly qualified with a
4457          class-key.  */
4458       if (INHERITED_VALUE_BINDING_P (binding)
4459           && BINDING_VALUE (binding)
4460           && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4461           && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4462           && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4463         {
4464           old_decl = BINDING_TYPE (binding);
4465           BINDING_TYPE (binding) = BINDING_VALUE (binding);
4466           BINDING_VALUE (binding) = NULL_TREE;
4467           INHERITED_VALUE_BINDING_P (binding) = 0;
4468         }
4469       else
4470         old_decl = BINDING_VALUE (binding);
4471
4472       /* Find the previous binding of name on the class-shadowed
4473          list, and update it.  */
4474       for (shadow = class_binding_level->class_shadowed;
4475            shadow;
4476            shadow = TREE_CHAIN (shadow))
4477         if (TREE_PURPOSE (shadow) == name
4478             && TREE_TYPE (shadow) == old_decl)
4479           {
4480             BINDING_VALUE (binding) = x;
4481             INHERITED_VALUE_BINDING_P (binding) = 0;
4482             TREE_TYPE (shadow) = x;
4483             IDENTIFIER_CLASS_VALUE (name) = x;
4484             return;
4485           }
4486     }
4487
4488   /* If we didn't replace an existing binding, put the binding on the
4489      stack of bindings for the identifier, and update the shadowed list.  */
4490   if (push_class_binding (name, x))
4491     {
4492       class_binding_level->class_shadowed
4493         = tree_cons (name, NULL,
4494                      class_binding_level->class_shadowed);
4495       /* Record the value we are binding NAME to so that we can know
4496          what to pop later.  */
4497       TREE_TYPE (class_binding_level->class_shadowed) = x;
4498     }
4499 }
4500
4501 /* Insert another USING_DECL into the current binding level, returning
4502    this declaration. If this is a redeclaration, do nothing, and
4503    return NULL_TREE if this not in namespace scope (in namespace
4504    scope, a using decl might extend any previous bindings).  */
4505
4506 tree
4507 push_using_decl (scope, name)
4508      tree scope;
4509      tree name;
4510 {
4511   tree decl;
4512
4513   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4514   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4515   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4516     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4517       break;
4518   if (decl)
4519     return namespace_bindings_p () ? decl : NULL_TREE;
4520   decl = build_lang_decl (USING_DECL, name, void_type_node);
4521   DECL_INITIAL (decl) = scope;
4522   TREE_CHAIN (decl) = current_binding_level->usings;
4523   current_binding_level->usings = decl;
4524   return decl;
4525 }
4526
4527 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4528    changed (i.e. there was already a directive), or the fresh
4529    TREE_LIST otherwise.  */
4530
4531 tree
4532 push_using_directive (used)
4533      tree used;
4534 {
4535   tree ud = current_binding_level->using_directives;
4536   tree iter, ancestor;
4537
4538   /* Check if we already have this. */
4539   if (purpose_member (used, ud) != NULL_TREE)
4540     return NULL_TREE;
4541
4542   /* Recursively add all namespaces used. */
4543   for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4544     push_using_directive (TREE_PURPOSE (iter));
4545
4546   ancestor = namespace_ancestor (current_decl_namespace (), used);
4547   ud = current_binding_level->using_directives;
4548   ud = tree_cons (used, ancestor, ud);
4549   current_binding_level->using_directives = ud;
4550   return ud;
4551 }
4552
4553 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4554    other definitions already in place.  We get around this by making
4555    the value of the identifier point to a list of all the things that
4556    want to be referenced by that name.  It is then up to the users of
4557    that name to decide what to do with that list.
4558
4559    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
4560    DECL_TEMPLATE_RESULT.  It is dealt with the same way.
4561
4562    FLAGS is a bitwise-or of the following values:
4563      PUSH_LOCAL: Bind DECL in the current scope, rather than at
4564                  namespace scope.
4565      PUSH_USING: DECL is being pushed as the result of a using
4566                  declaration.
4567
4568    The value returned may be a previous declaration if we guessed wrong
4569    about what language DECL should belong to (C or C++).  Otherwise,
4570    it's always DECL (and never something that's not a _DECL).  */
4571
4572 tree
4573 push_overloaded_decl (decl, flags)
4574      tree decl;
4575      int flags;
4576 {
4577   tree name = DECL_NAME (decl);
4578   tree old;
4579   tree new_binding;
4580   int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4581
4582   if (doing_global)
4583     old = namespace_binding (name, DECL_CONTEXT (decl));
4584   else
4585     old = lookup_name_current_level (name);
4586
4587   if (old)
4588     {
4589       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4590         {
4591           tree t = TREE_TYPE (old);
4592           if (IS_AGGR_TYPE (t) && warn_shadow
4593               && (! DECL_IN_SYSTEM_HEADER (decl)
4594                   || ! DECL_IN_SYSTEM_HEADER (old)))
4595             cp_warning ("`%#D' hides constructor for `%#T'", decl, t);
4596           old = NULL_TREE;
4597         }
4598       else if (is_overloaded_fn (old))
4599         {
4600           tree tmp;
4601
4602           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4603             {
4604               tree fn = OVL_CURRENT (tmp);
4605
4606               if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4607                   && !(flags & PUSH_USING)
4608                   && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4609                                 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4610                 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4611                           decl, fn);
4612
4613               if (duplicate_decls (decl, fn))
4614                 return fn;
4615             }
4616         }
4617       else if (old == error_mark_node)
4618         /* Ignore the undefined symbol marker.  */
4619         old = NULL_TREE;
4620       else
4621         {
4622           cp_error_at ("previous non-function declaration `%#D'", old);
4623           cp_error ("conflicts with function declaration `%#D'", decl);
4624           return decl;
4625         }
4626     }
4627
4628   if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4629     {
4630       if (old && TREE_CODE (old) != OVERLOAD)
4631         new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4632       else
4633         new_binding = ovl_cons (decl, old);
4634       if (flags & PUSH_USING)
4635         OVL_USED (new_binding) = 1;
4636     }
4637   else
4638     /* NAME is not ambiguous.  */
4639     new_binding = decl;
4640
4641   if (doing_global)
4642     set_namespace_binding (name, current_namespace, new_binding);
4643   else
4644     {
4645       /* We only create an OVERLOAD if there was a previous binding at
4646          this level, or if decl is a template. In the former case, we
4647          need to remove the old binding and replace it with the new
4648          binding.  We must also run through the NAMES on the binding
4649          level where the name was bound to update the chain.  */
4650
4651       if (TREE_CODE (new_binding) == OVERLOAD && old)
4652         {
4653           tree *d;
4654
4655           for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4656                *d;
4657                d = &TREE_CHAIN (*d))
4658             if (*d == old
4659                 || (TREE_CODE (*d) == TREE_LIST
4660                     && TREE_VALUE (*d) == old))
4661               {
4662                 if (TREE_CODE (*d) == TREE_LIST)
4663                   /* Just replace the old binding with the new.  */
4664                   TREE_VALUE (*d) = new_binding;
4665                 else
4666                   /* Build a TREE_LIST to wrap the OVERLOAD.  */
4667                   *d = tree_cons (NULL_TREE, new_binding,
4668                                   TREE_CHAIN (*d));
4669
4670                 /* And update the CPLUS_BINDING node.  */
4671                 BINDING_VALUE (IDENTIFIER_BINDING (name))
4672                   = new_binding;
4673                 return decl;
4674               }
4675
4676           /* We should always find a previous binding in this case.  */
4677           my_friendly_abort (0);
4678         }
4679
4680       /* Install the new binding.  */
4681       push_local_binding (name, new_binding, flags);
4682     }
4683
4684   return decl;
4685 }
4686 \f
4687 /* Generate an implicit declaration for identifier FUNCTIONID
4688    as a function of type int ().  Print a warning if appropriate.  */
4689
4690 tree
4691 implicitly_declare (functionid)
4692      tree functionid;
4693 {
4694   register tree decl;
4695
4696   /* We used to reuse an old implicit decl here,
4697      but this loses with inline functions because it can clobber
4698      the saved decl chains.  */
4699   decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4700
4701   DECL_EXTERNAL (decl) = 1;
4702   TREE_PUBLIC (decl) = 1;
4703
4704   /* ISO standard says implicit declarations are in the innermost block.
4705      So we record the decl in the standard fashion.  */
4706   pushdecl (decl);
4707   rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
4708
4709   if (warn_implicit
4710       /* Only one warning per identifier.  */
4711       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4712     {
4713       cp_pedwarn ("implicit declaration of function `%#D'", decl);
4714     }
4715
4716   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4717
4718   return decl;
4719 }
4720
4721 /* Return zero if the declaration NEWDECL is valid
4722    when the declaration OLDDECL (assumed to be for the same name)
4723    has already been seen.
4724    Otherwise return an error message format string with a %s
4725    where the identifier should go.  */
4726
4727 static const char *
4728 redeclaration_error_message (newdecl, olddecl)
4729      tree newdecl, olddecl;
4730 {
4731   if (TREE_CODE (newdecl) == TYPE_DECL)
4732     {
4733       /* Because C++ can put things into name space for free,
4734          constructs like "typedef struct foo { ... } foo"
4735          would look like an erroneous redeclaration.  */
4736       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4737         return 0;
4738       else
4739         return "redefinition of `%#D'";
4740     }
4741   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4742     {
4743       /* If this is a pure function, its olddecl will actually be
4744          the original initialization to `0' (which we force to call
4745          abort()).  Don't complain about redefinition in this case.  */
4746       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4747         return 0;
4748
4749       /* If both functions come from different namespaces, this is not
4750          a redeclaration - this is a conflict with a used function. */
4751       if (DECL_NAMESPACE_SCOPE_P (olddecl)
4752           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4753         return "`%D' conflicts with used function";
4754
4755       /* We'll complain about linkage mismatches in
4756          warn_extern_redeclared_static.  */
4757
4758       /* Defining the same name twice is no good.  */
4759       if (DECL_INITIAL (olddecl) != NULL_TREE
4760           && DECL_INITIAL (newdecl) != NULL_TREE)
4761         {
4762           if (DECL_NAME (olddecl) == NULL_TREE)
4763             return "`%#D' not declared in class";
4764           else
4765             return "redefinition of `%#D'";
4766         }
4767       return 0;
4768     }
4769   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4770     {
4771       if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4772            && (DECL_TEMPLATE_RESULT (newdecl)
4773                != DECL_TEMPLATE_RESULT (olddecl))
4774            && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4775            && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4776           || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4777               && COMPLETE_TYPE_P (TREE_TYPE (newdecl))
4778               && COMPLETE_TYPE_P (TREE_TYPE (olddecl))))
4779         return "redefinition of `%#D'";
4780       return 0;
4781     }
4782   else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
4783     {
4784       /* Objects declared at top level:  */
4785       /* If at least one is a reference, it's ok.  */
4786       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4787         return 0;
4788       /* Reject two definitions.  */
4789       return "redefinition of `%#D'";
4790     }
4791   else
4792     {
4793       /* Objects declared with block scope:  */
4794       /* Reject two definitions, and reject a definition
4795          together with an external reference.  */
4796       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4797         return "redeclaration of `%#D'";
4798       return 0;
4799     }
4800 }
4801 \f
4802 /* Create a new label, named ID.  */
4803
4804 static tree
4805 make_label_decl (id, local_p)
4806      tree id;
4807      int local_p;
4808 {
4809   tree decl;
4810
4811   decl = build_decl (LABEL_DECL, id, void_type_node);
4812   if (expanding_p)
4813     /* Make sure every label has an rtx.  */
4814     label_rtx (decl);
4815
4816   DECL_CONTEXT (decl) = current_function_decl;
4817   DECL_MODE (decl) = VOIDmode;
4818   C_DECLARED_LABEL_FLAG (decl) = local_p;
4819
4820   /* Say where one reference is to the label, for the sake of the
4821      error if it is not defined.  */
4822   DECL_SOURCE_LINE (decl) = lineno;
4823   DECL_SOURCE_FILE (decl) = input_filename;
4824
4825   /* Record the fact that this identifier is bound to this label.  */
4826   SET_IDENTIFIER_LABEL_VALUE (id, decl);
4827
4828   return decl;
4829 }
4830
4831 /* Record this label on the list of used labels so that we can check
4832    at the end of the function to see whether or not the label was
4833    actually defined, and so we can check when the label is defined whether
4834    this use is valid.  */
4835
4836 static void
4837 use_label (decl)
4838      tree decl;
4839 {
4840   if (named_label_uses == NULL
4841       || named_label_uses->names_in_scope != current_binding_level->names
4842       || named_label_uses->label_decl != decl)
4843     {
4844       struct named_label_use_list *new_ent;
4845       new_ent = ((struct named_label_use_list *)
4846                  ggc_alloc (sizeof (struct named_label_use_list)));
4847       new_ent->label_decl = decl;
4848       new_ent->names_in_scope = current_binding_level->names;
4849       new_ent->binding_level = current_binding_level;
4850       new_ent->lineno_o_goto = lineno;
4851       new_ent->filename_o_goto = input_filename;
4852       new_ent->next = named_label_uses;
4853       named_label_uses = new_ent;
4854     }
4855 }
4856
4857 /* Look for a label named ID in the current function.  If one cannot
4858    be found, create one.  (We keep track of used, but undefined,
4859    labels, and complain about them at the end of a function.)  */
4860
4861 tree
4862 lookup_label (id)
4863      tree id;
4864 {
4865   tree decl;
4866   struct named_label_list *ent;
4867
4868   /* You can't use labels at global scope.  */
4869   if (current_function_decl == NULL_TREE)
4870     {
4871       error ("label `%s' referenced outside of any function",
4872              IDENTIFIER_POINTER (id));
4873       return NULL_TREE;
4874     }
4875
4876   /* See if we've already got this label.  */
4877   decl = IDENTIFIER_LABEL_VALUE (id);
4878   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4879     return decl;
4880
4881   /* Record this label on the list of labels used in this function.
4882      We do this before calling make_label_decl so that we get the
4883      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
4884   ent = ((struct named_label_list *)
4885          ggc_alloc_cleared (sizeof (struct named_label_list)));
4886   ent->old_value = IDENTIFIER_LABEL_VALUE (id);
4887   ent->next = named_labels;
4888   named_labels = ent;
4889
4890   /* We need a new label.  */
4891   decl = make_label_decl (id, /*local_p=*/0);
4892
4893   /* Now fill in the information we didn't have before.  */
4894   ent->label_decl = decl;
4895
4896   return decl;
4897 }
4898
4899 /* Declare a local label named ID.  */
4900
4901 tree
4902 declare_local_label (id)
4903      tree id;
4904 {
4905   tree decl;
4906
4907   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4908      this scope we can restore the old value of
4909      IDENTIFIER_TYPE_VALUE.  */
4910   current_binding_level->shadowed_labels
4911     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4912                  current_binding_level->shadowed_labels);
4913   /* Look for the label.  */
4914   decl = make_label_decl (id, /*local_p=*/1);
4915   /* Now fill in the information we didn't have before.  */
4916   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4917
4918   return decl;
4919 }
4920
4921 /* Returns nonzero if it is ill-formed to jump past the declaration of
4922    DECL.  Returns 2 if it's also a real problem.  */
4923
4924 static int
4925 decl_jump_unsafe (decl)
4926      tree decl;
4927 {
4928   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
4929     return 0;
4930
4931   if (DECL_INITIAL (decl) == NULL_TREE
4932       && pod_type_p (TREE_TYPE (decl)))
4933     return 0;
4934
4935   /* This is really only important if we're crossing an initialization.
4936      The POD stuff is just pedantry; why should it matter if the class
4937      contains a field of pointer to member type?  */
4938   if (DECL_INITIAL (decl)
4939       || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
4940     return 2;
4941   return 1;
4942 }
4943
4944 /* Check that a single previously seen jump to a newly defined label
4945    is OK.  DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
4946    the jump context; NAMES are the names in scope in LEVEL at the jump
4947    context; FILE and LINE are the source position of the jump or 0.  */
4948
4949 static void
4950 check_previous_goto_1 (decl, level, names, file, line)
4951      tree decl;
4952      struct binding_level *level;
4953      tree names;
4954      const char *file;
4955      int line;
4956 {
4957   int identified = 0;
4958   int saw_eh = 0;
4959   struct binding_level *b = current_binding_level;
4960   for (; b; b = b->level_chain)
4961     {
4962       tree new_decls = b->names;
4963       tree old_decls = (b == level ? names : NULL_TREE);
4964       for (; new_decls != old_decls;
4965            new_decls = TREE_CHAIN (new_decls))
4966         {
4967           int problem = decl_jump_unsafe (new_decls);
4968           if (! problem)
4969             continue;
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
4983           if (problem > 1)
4984             cp_error_at ("  crosses initialization of `%#D'",
4985                          new_decls);
4986           else
4987             cp_pedwarn_at ("  enters scope of non-POD `%#D'",
4988                            new_decls);
4989         }
4990
4991       if (b == level)
4992         break;
4993       if ((b->is_try_scope || b->is_catch_scope) && ! saw_eh)
4994         {
4995           if (! identified)
4996             {
4997               if (decl)
4998                 cp_pedwarn ("jump to label `%D'", decl);
4999               else
5000                 pedwarn ("jump to case label");
5001
5002               if (file)
5003                 pedwarn_with_file_and_line (file, line, "  from here");
5004               identified = 1;
5005             }
5006           if (b->is_try_scope)
5007             error ("  enters try block");
5008           else
5009             error ("  enters catch block");
5010           saw_eh = 1;
5011         }
5012     }
5013 }
5014
5015 static void
5016 check_previous_goto (use)
5017      struct named_label_use_list *use;
5018 {
5019   check_previous_goto_1 (use->label_decl, use->binding_level,
5020                          use->names_in_scope, use->filename_o_goto,
5021                          use->lineno_o_goto);
5022 }
5023
5024 static void
5025 check_switch_goto (level)
5026      struct binding_level *level;
5027 {
5028   check_previous_goto_1 (NULL_TREE, level, level->names, NULL, 0);
5029 }
5030
5031 /* Check that any previously seen jumps to a newly defined label DECL
5032    are OK.  Called by define_label.  */
5033
5034 static void
5035 check_previous_gotos (decl)
5036      tree decl;
5037 {
5038   struct named_label_use_list **usep;
5039
5040   if (! TREE_USED (decl))
5041     return;
5042
5043   for (usep = &named_label_uses; *usep; )
5044     {
5045       struct named_label_use_list *use = *usep;
5046       if (use->label_decl == decl)
5047         {
5048           check_previous_goto (use);
5049           *usep = use->next;
5050         }
5051       else
5052         usep = &(use->next);
5053     }
5054 }
5055
5056 /* Check that a new jump to a label DECL is OK.  Called by
5057    finish_goto_stmt.  */
5058
5059 void
5060 check_goto (decl)
5061      tree decl;
5062 {
5063   int identified = 0;
5064   tree bad;
5065   struct named_label_list *lab;
5066
5067   /* We can't know where a computed goto is jumping.  So we assume
5068      that it's OK.  */
5069   if (! DECL_P (decl))
5070     return;
5071
5072   /* If the label hasn't been defined yet, defer checking.  */
5073   if (! DECL_INITIAL (decl))
5074     {
5075       use_label (decl);
5076       return;
5077     }
5078
5079   for (lab = named_labels; lab; lab = lab->next)
5080     if (decl == lab->label_decl)
5081       break;
5082
5083   /* If the label is not on named_labels it's a gcc local label, so
5084      it must be in an outer scope, so jumping to it is always OK.  */
5085   if (lab == 0)
5086     return;
5087
5088   if ((lab->in_try_scope || lab->in_catch_scope || lab->bad_decls)
5089       && !identified)
5090     {
5091       cp_pedwarn_at ("jump to label `%D'", decl);
5092       pedwarn ("  from here");
5093       identified = 1;
5094     }
5095
5096   for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad))
5097     {
5098       tree b = TREE_VALUE (bad);
5099       int u = decl_jump_unsafe (b);
5100
5101       if (u > 1 && DECL_ARTIFICIAL (b))
5102         /* Can't skip init of __exception_info.  */
5103         cp_error_at ("  enters catch block", b);
5104       else if (u > 1)
5105         cp_error_at ("  skips initialization of `%#D'", b);
5106       else
5107         cp_pedwarn_at ("  enters scope of non-POD `%#D'", b);
5108     }
5109
5110   if (lab->in_try_scope)
5111     error ("  enters try block");
5112   else if (lab->in_catch_scope)
5113     error ("  enters catch block");
5114 }
5115
5116 /* Define a label, specifying the location in the source file.
5117    Return the LABEL_DECL node for the label, if the definition is valid.
5118    Otherwise return 0.  */
5119
5120 tree
5121 define_label (filename, line, name)
5122      const char *filename;
5123      int line;
5124      tree name;
5125 {
5126   tree decl = lookup_label (name);
5127   struct named_label_list *ent;
5128   register struct binding_level *p;
5129
5130   for (ent = named_labels; ent; ent = ent->next)
5131     if (ent->label_decl == decl)
5132       break;
5133
5134   /* After labels, make any new cleanups in the function go into their
5135      own new (temporary) binding contour.  */
5136   for (p = current_binding_level; !(p->parm_flag); p = p->level_chain)
5137     p->more_cleanups_ok = 0;
5138
5139   if (name == get_identifier ("wchar_t"))
5140     cp_pedwarn ("label named wchar_t");
5141
5142   if (DECL_INITIAL (decl) != NULL_TREE)
5143     {
5144       cp_error ("duplicate label `%D'", decl);
5145       return 0;
5146     }
5147   else
5148     {
5149       /* Mark label as having been defined.  */
5150       DECL_INITIAL (decl) = error_mark_node;
5151       /* Say where in the source.  */
5152       DECL_SOURCE_FILE (decl) = filename;
5153       DECL_SOURCE_LINE (decl) = line;
5154       if (ent)
5155         {
5156           ent->names_in_scope = current_binding_level->names;
5157           ent->binding_level = current_binding_level;
5158         }
5159       check_previous_gotos (decl);
5160       current_function_return_value = NULL_TREE;
5161       return decl;
5162     }
5163 }
5164
5165 struct cp_switch
5166 {
5167   struct binding_level *level;
5168   struct cp_switch *next;
5169   /* The SWITCH_STMT being built.  */
5170   tree switch_stmt;
5171   /* A splay-tree mapping the low element of a case range to the high
5172      element, or NULL_TREE if there is no high element.  Used to
5173      determine whether or not a new case label duplicates an old case
5174      label.  We need a tree, rather than simply a hash table, because
5175      of the GNU case range extension.  */
5176   splay_tree cases;
5177 };
5178
5179 /* A stack of the currently active switch statements.  The innermost
5180    switch statement is on the top of the stack.  There is no need to
5181    mark the stack for garbage collection because it is only active
5182    during the processing of the body of a function, and we never
5183    collect at that point.  */
5184
5185 static struct cp_switch *switch_stack;
5186
5187 /* Called right after a switch-statement condition is parsed.
5188    SWITCH_STMT is the switch statement being parsed.  */
5189
5190 void
5191 push_switch (switch_stmt)
5192      tree switch_stmt;
5193 {
5194   struct cp_switch *p
5195     = (struct cp_switch *) xmalloc (sizeof (struct cp_switch));
5196   p->level = current_binding_level;
5197   p->next = switch_stack;
5198   p->switch_stmt = switch_stmt;
5199   p->cases = splay_tree_new (case_compare, NULL, NULL);
5200   switch_stack = p;
5201 }
5202
5203 void
5204 pop_switch ()
5205 {
5206   struct cp_switch *cs;
5207
5208   cs = switch_stack;
5209   splay_tree_delete (cs->cases);
5210   switch_stack = switch_stack->next;
5211   free (cs);
5212 }
5213
5214 /* Note that we've seen a definition of a case label, and complain if this
5215    is a bad place for one.  */
5216
5217 tree
5218 finish_case_label (low_value, high_value)
5219      tree low_value;
5220      tree high_value;
5221 {
5222   tree cond, r;
5223   register struct binding_level *p;
5224
5225   if (! switch_stack)
5226     {
5227       if (high_value)
5228         error ("case label not within a switch statement");
5229       else if (low_value)
5230         cp_error ("case label `%E' not within a switch statement",
5231                   low_value);
5232       else
5233         error ("`default' label not within a switch statement");
5234       return NULL_TREE;
5235     }
5236
5237   if (processing_template_decl)
5238     {
5239       tree label;
5240
5241       /* For templates, just add the case label; we'll do semantic
5242          analysis at instantiation-time.  */
5243       label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
5244       return add_stmt (build_case_label (low_value, high_value, label));
5245     }
5246
5247   /* Find the condition on which this switch statement depends.  */
5248   cond = SWITCH_COND (switch_stack->switch_stmt);
5249   if (cond && TREE_CODE (cond) == TREE_LIST)
5250     cond = TREE_VALUE (cond);
5251
5252   r = c_add_case_label (switch_stack->cases, cond, low_value, high_value);
5253   if (r == error_mark_node)
5254     r = NULL_TREE;
5255
5256   check_switch_goto (switch_stack->level);
5257
5258   /* After labels, make any new cleanups in the function go into their
5259      own new (temporary) binding contour.  */
5260   for (p = current_binding_level; !(p->parm_flag); p = p->level_chain)
5261     p->more_cleanups_ok = 0;
5262   current_function_return_value = NULL_TREE;
5263
5264   return r;
5265 }
5266 \f
5267 /* Return the list of declarations of the current level.
5268    Note that this list is in reverse order unless/until
5269    you nreverse it; and when you do nreverse it, you must
5270    store the result back using `storedecls' or you will lose.  */
5271
5272 tree
5273 getdecls ()
5274 {
5275   return current_binding_level->names;
5276 }
5277
5278 /* Return the list of type-tags (for structs, etc) of the current level.  */
5279
5280 tree
5281 gettags ()
5282 {
5283   return current_binding_level->tags;
5284 }
5285
5286 /* Store the list of declarations of the current level.
5287    This is done for the parameter declarations of a function being defined,
5288    after they are modified in the light of any missing parameters.  */
5289
5290 static void
5291 storedecls (decls)
5292      tree decls;
5293 {
5294   current_binding_level->names = decls;
5295 }
5296
5297 /* Similarly, store the list of tags of the current level.  */
5298
5299 void
5300 storetags (tags)
5301      tree tags;
5302 {
5303   current_binding_level->tags = tags;
5304 }
5305 \f
5306 /* Given NAME, an IDENTIFIER_NODE,
5307    return the structure (or union or enum) definition for that name.
5308    Searches binding levels from BINDING_LEVEL up to the global level.
5309    If THISLEVEL_ONLY is nonzero, searches only the specified context
5310    (but skips any tag-transparent contexts to find one that is
5311    meaningful for tags).
5312    FORM says which kind of type the caller wants;
5313    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5314    If the wrong kind of type is found, and it's not a template, an error is
5315    reported.  */
5316
5317 static tree
5318 lookup_tag (form, name, binding_level, thislevel_only)
5319      enum tree_code form;
5320      tree name;
5321      struct binding_level *binding_level;
5322      int thislevel_only;
5323 {
5324   register struct binding_level *level;
5325   /* Non-zero if, we should look past a template parameter level, even
5326      if THISLEVEL_ONLY.  */
5327   int allow_template_parms_p = 1;
5328
5329   for (level = binding_level; level; level = level->level_chain)
5330     {
5331       register tree tail;
5332       if (ANON_AGGRNAME_P (name))
5333         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5334           {
5335             /* There's no need for error checking here, because
5336                anon names are unique throughout the compilation.  */
5337             if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
5338               return TREE_VALUE (tail);
5339           }
5340       else if (level->namespace_p)
5341         /* Do namespace lookup. */
5342         for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
5343           {
5344             tree old = binding_for_name (name, tail);
5345
5346             /* If we just skipped past a template parameter level,
5347                even though THISLEVEL_ONLY, and we find a template
5348                class declaration, then we use the _TYPE node for the
5349                template.  See the example below.  */
5350             if (thislevel_only && !allow_template_parms_p
5351                 && old && BINDING_VALUE (old)
5352                 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
5353               old = TREE_TYPE (BINDING_VALUE (old));
5354             else
5355               old = BINDING_TYPE (old);
5356
5357             /* If it has an original type, it is a typedef, and we
5358                should not return it.  */
5359             if (old && DECL_ORIGINAL_TYPE (TYPE_NAME (old)))
5360               old = NULL_TREE;
5361             if (old && TREE_CODE (old) != form
5362                 && !(form != ENUMERAL_TYPE && TREE_CODE (old) == TEMPLATE_DECL))
5363               {
5364                 cp_error ("`%#D' redeclared as %C", old, form);
5365                 return NULL_TREE;
5366               }
5367             if (old)
5368               return old;
5369             if (thislevel_only || tail == global_namespace)
5370               return NULL_TREE;
5371           }
5372       else
5373         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5374           {
5375             if (TREE_PURPOSE (tail) == name)
5376               {
5377                 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5378                 /* Should tighten this up; it'll probably permit
5379                    UNION_TYPE and a struct template, for example.  */
5380                 if (code != form
5381                     && !(form != ENUMERAL_TYPE && code == TEMPLATE_DECL))
5382                   {
5383                     /* Definition isn't the kind we were looking for.  */
5384                     cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
5385                               form);
5386                     return NULL_TREE;
5387                   }
5388                 return TREE_VALUE (tail);
5389               }
5390           }
5391       if (thislevel_only && ! level->tag_transparent)
5392         {
5393           if (level->template_parms_p && allow_template_parms_p)
5394             {
5395               /* We must deal with cases like this:
5396
5397                    template <class T> struct S;
5398                    template <class T> struct S {};
5399
5400                  When looking up `S', for the second declaration, we
5401                  would like to find the first declaration.  But, we
5402                  are in the pseudo-global level created for the
5403                  template parameters, rather than the (surrounding)
5404                  namespace level.  Thus, we keep going one more level,
5405                  even though THISLEVEL_ONLY is non-zero.  */
5406               allow_template_parms_p = 0;
5407               continue;
5408             }
5409           else
5410             return NULL_TREE;
5411         }
5412     }
5413   return NULL_TREE;
5414 }
5415
5416 #if 0
5417 void
5418 set_current_level_tags_transparency (tags_transparent)
5419      int tags_transparent;
5420 {
5421   current_binding_level->tag_transparent = tags_transparent;
5422 }
5423 #endif
5424
5425 /* Given a type, find the tag that was defined for it and return the tag name.
5426    Otherwise return 0.  However, the value can never be 0
5427    in the cases in which this is used.
5428
5429    C++: If NAME is non-zero, this is the new name to install.  This is
5430    done when replacing anonymous tags with real tag names.  */
5431
5432 static tree
5433 lookup_tag_reverse (type, name)
5434      tree type;
5435      tree name;
5436 {
5437   register struct binding_level *level;
5438
5439   for (level = current_binding_level; level; level = level->level_chain)
5440     {
5441       register tree tail;
5442       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5443         {
5444           if (TREE_VALUE (tail) == type)
5445             {
5446               if (name)
5447                 TREE_PURPOSE (tail) = name;
5448               return TREE_PURPOSE (tail);
5449             }
5450         }
5451     }
5452   return NULL_TREE;
5453 }
5454 \f
5455 /* Look up NAME in the NAMESPACE.  */
5456
5457 tree
5458 lookup_namespace_name (namespace, name)
5459      tree namespace, name;
5460 {
5461   tree val;
5462   tree template_id = NULL_TREE;
5463
5464   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5465
5466   if (TREE_CODE (name) == NAMESPACE_DECL)
5467     /* This happens for A::B<int> when B is a namespace. */
5468     return name;
5469   else if (TREE_CODE (name) == TEMPLATE_DECL)
5470     {
5471       /* This happens for A::B where B is a template, and there are no
5472          template arguments.  */
5473       cp_error ("invalid use of `%D'", name);
5474       return error_mark_node;
5475     }
5476
5477   namespace = ORIGINAL_NAMESPACE (namespace);
5478
5479   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5480     {
5481       template_id = name;
5482       name = TREE_OPERAND (name, 0);
5483       if (TREE_CODE (name) == OVERLOAD)
5484         name = DECL_NAME (OVL_CURRENT (name));
5485       else if (DECL_P (name))
5486         name = DECL_NAME (name);
5487     }
5488
5489   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5490
5491   val = make_node (CPLUS_BINDING);
5492   if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5493     return error_mark_node;
5494
5495   if (BINDING_VALUE (val))
5496     {
5497       val = BINDING_VALUE (val);
5498
5499       if (template_id)
5500         {
5501           if (DECL_CLASS_TEMPLATE_P (val))
5502             val = lookup_template_class (val,
5503                                          TREE_OPERAND (template_id, 1),
5504                                          /*in_decl=*/NULL_TREE,
5505                                          /*context=*/NULL_TREE,
5506                                          /*entering_scope=*/0,
5507                                          /*complain=*/1);
5508           else if (DECL_FUNCTION_TEMPLATE_P (val)
5509                    || TREE_CODE (val) == OVERLOAD)
5510             val = lookup_template_function (val,
5511                                             TREE_OPERAND (template_id, 1));
5512           else
5513             {
5514               cp_error ("`%D::%D' is not a template",
5515                         namespace, name);
5516               return error_mark_node;
5517             }
5518         }
5519
5520       /* If we have a single function from a using decl, pull it out.  */
5521       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5522         val = OVL_FUNCTION (val);
5523       return val;
5524     }
5525
5526   cp_error ("`%D' undeclared in namespace `%D'", name, namespace);
5527   return error_mark_node;
5528 }
5529
5530 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
5531
5532 static unsigned long
5533 typename_hash (k)
5534      hash_table_key k;
5535 {
5536   unsigned long hash;
5537   tree t;
5538
5539   t = (tree) k;
5540   hash = (((unsigned long) TYPE_CONTEXT (t))
5541           ^ ((unsigned long) DECL_NAME (TYPE_NAME (t))));
5542
5543   return hash;
5544 }
5545
5546 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
5547
5548 static bool
5549 typename_compare (k1, k2)
5550      hash_table_key k1;
5551      hash_table_key k2;
5552 {
5553   tree t1;
5554   tree t2;
5555   tree d1;
5556   tree d2;
5557
5558   t1 = (tree) k1;
5559   t2 = (tree) k2;
5560   d1 = TYPE_NAME (t1);
5561   d2 = TYPE_NAME (t2);
5562
5563   return (DECL_NAME (d1) == DECL_NAME (d2)
5564           && same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))
5565           && ((TREE_TYPE (t1) != NULL_TREE)
5566               == (TREE_TYPE (t2) != NULL_TREE))
5567           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5568           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5569 }
5570
5571 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
5572    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
5573    is non-NULL, this type is being created by the implicit typename
5574    extension, and BASE_TYPE is a type named `t' in some base class of
5575    `T' which depends on template parameters.
5576
5577    Returns the new TYPENAME_TYPE.  */
5578
5579 tree
5580 build_typename_type (context, name, fullname, base_type)
5581      tree context;
5582      tree name;
5583      tree fullname;
5584      tree base_type;
5585 {
5586   tree t;
5587   tree d;
5588   struct hash_entry *e;
5589
5590   static struct hash_table ht;
5591
5592   if (!ht.table)
5593     {
5594       static struct hash_table *h = &ht;
5595
5596       hash_table_init (&ht, &hash_newfunc, &typename_hash, &typename_compare);
5597       ggc_add_tree_hash_table_root (&h, 1);
5598     }
5599
5600   /* Build the TYPENAME_TYPE.  */
5601   t = make_aggr_type (TYPENAME_TYPE);
5602   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5603   TYPENAME_TYPE_FULLNAME (t) = fullname;
5604   TREE_TYPE (t) = base_type;
5605
5606   /* Build the corresponding TYPE_DECL.  */
5607   d = build_decl (TYPE_DECL, name, t);
5608   TYPE_NAME (TREE_TYPE (d)) = d;
5609   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5610   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5611   DECL_ARTIFICIAL (d) = 1;
5612
5613   /* See if we already have this type.  */
5614   e = hash_lookup (&ht, t, /*create=*/false, /*copy=*/0);
5615   if (e)
5616     t = (tree) e->key;
5617   else
5618     /* Insert the type into the table.  */
5619     hash_lookup (&ht, t, /*create=*/true, /*copy=*/0);
5620
5621   return t;
5622 }
5623
5624 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
5625    unless an error occurs, in which case error_mark_node is returned.
5626    If COMPLAIN zero, don't complain about any errors that occur.  */
5627
5628 tree
5629 make_typename_type (context, name, complain)
5630      tree context, name;
5631      int complain;
5632 {
5633   tree fullname;
5634
5635   if (TYPE_P (name))
5636     {
5637       if (!(TYPE_LANG_SPECIFIC (name)
5638             && (CLASSTYPE_IS_TEMPLATE (name)
5639                 || CLASSTYPE_USE_TEMPLATE (name))))
5640         name = TYPE_IDENTIFIER (name);
5641       else
5642         /* Create a TEMPLATE_ID_EXPR for the type.  */
5643         name = build_nt (TEMPLATE_ID_EXPR,
5644                          CLASSTYPE_TI_TEMPLATE (name),
5645                          CLASSTYPE_TI_ARGS (name));
5646     }
5647   else if (TREE_CODE (name) == TYPE_DECL)
5648     name = DECL_NAME (name);
5649
5650   fullname = name;
5651
5652   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5653     {
5654       name = TREE_OPERAND (name, 0);
5655       if (TREE_CODE (name) == TEMPLATE_DECL)
5656         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5657     }
5658   if (TREE_CODE (name) != IDENTIFIER_NODE)
5659     my_friendly_abort (2000);
5660
5661   if (TREE_CODE (context) == NAMESPACE_DECL)
5662     {
5663       /* We can get here from typename_sub0 in the explicit_template_type
5664          expansion.  Just fail.  */
5665       if (complain)
5666         cp_error ("no class template named `%#T' in `%#T'",
5667                   name, context);
5668       return error_mark_node;
5669     }
5670
5671   if (! uses_template_parms (context)
5672       || currently_open_class (context))
5673     {
5674       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5675         {
5676           tree tmpl = NULL_TREE;
5677           if (IS_AGGR_TYPE (context))
5678             tmpl = lookup_field (context, name, 0, 0);
5679           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5680             {
5681               if (complain)
5682                 cp_error ("no class template named `%#T' in `%#T'",
5683                           name, context);
5684               return error_mark_node;
5685             }
5686
5687           return lookup_template_class (tmpl,
5688                                         TREE_OPERAND (fullname, 1),
5689                                         NULL_TREE, context,
5690                                         /*entering_scope=*/0,
5691                                         /*complain=*/1);
5692         }
5693       else
5694         {
5695           tree t;
5696
5697           if (!IS_AGGR_TYPE (context))
5698             {
5699               if (complain)
5700                 cp_error ("no type named `%#T' in `%#T'", name, context);
5701               return error_mark_node;
5702             }
5703
5704           t = lookup_field (context, name, 0, 1);
5705           if (t)
5706             return TREE_TYPE (t);
5707         }
5708     }
5709
5710   /* If the CONTEXT is not a template type, then either the field is
5711      there now or its never going to be.  */
5712   if (!uses_template_parms (context))
5713     {
5714       if (complain)
5715         cp_error ("no type named `%#T' in `%#T'", name, context);
5716       return error_mark_node;
5717     }
5718
5719
5720   return build_typename_type (context, name, fullname,  NULL_TREE);
5721 }
5722
5723 /* Select the right _DECL from multiple choices. */
5724
5725 static tree
5726 select_decl (binding, flags)
5727      tree binding;
5728      int flags;
5729 {
5730   tree val;
5731   val = BINDING_VALUE (binding);
5732
5733   /* When we implicitly declare some builtin entity, we mark it
5734      DECL_ANTICIPATED, so that we know to ignore it until it is
5735      really declared.  */
5736   if (val && DECL_P (val)
5737       && DECL_LANG_SPECIFIC (val)
5738       && DECL_ANTICIPATED (val))
5739     return NULL_TREE;
5740
5741   if (LOOKUP_NAMESPACES_ONLY (flags))
5742     {
5743       /* We are not interested in types. */
5744       if (val && TREE_CODE (val) == NAMESPACE_DECL)
5745         return val;
5746       return NULL_TREE;
5747     }
5748
5749   /* If we could have a type and
5750      we have nothing or we need a type and have none.  */
5751   if (BINDING_TYPE (binding)
5752       && (!val || ((flags & LOOKUP_PREFER_TYPES)
5753                    && TREE_CODE (val) != TYPE_DECL)))
5754     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5755   /* Don't return non-types if we really prefer types. */
5756   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
5757            && (TREE_CODE (val) != TEMPLATE_DECL
5758                || !DECL_CLASS_TEMPLATE_P (val)))
5759     val = NULL_TREE;
5760
5761   return val;
5762 }
5763
5764 /* Unscoped lookup of a global: iterate over current namespaces,
5765    considering using-directives.  If SPACESP is non-NULL, store a list
5766    of the namespaces we've considered in it.  */
5767
5768 tree
5769 unqualified_namespace_lookup (name, flags, spacesp)
5770      tree name;
5771      int flags;
5772      tree *spacesp;
5773 {
5774   tree b = make_node (CPLUS_BINDING);
5775   tree initial = current_decl_namespace();
5776   tree scope = initial;
5777   tree siter;
5778   struct binding_level *level;
5779   tree val = NULL_TREE;
5780
5781   if (spacesp)
5782     *spacesp = NULL_TREE;
5783
5784   for (; !val; scope = CP_DECL_CONTEXT (scope))
5785     {
5786       if (spacesp)
5787         *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5788       val = binding_for_name (name, scope);
5789
5790       /* Initialize binding for this context. */
5791       BINDING_VALUE (b) = BINDING_VALUE (val);
5792       BINDING_TYPE (b) = BINDING_TYPE (val);
5793
5794       /* Add all _DECLs seen through local using-directives. */
5795       for (level = current_binding_level;
5796            !level->namespace_p;
5797            level = level->level_chain)
5798         if (!lookup_using_namespace (name, b, level->using_directives,
5799                                      scope, flags, spacesp))
5800           /* Give up because of error. */
5801           return error_mark_node;
5802
5803       /* Add all _DECLs seen through global using-directives. */
5804       /* XXX local and global using lists should work equally. */
5805       siter = initial;
5806       while (1)
5807         {
5808           if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5809                                        scope, flags, spacesp))
5810             /* Give up because of error. */
5811             return error_mark_node;
5812           if (siter == scope) break;
5813           siter = CP_DECL_CONTEXT (siter);
5814         }
5815
5816       val = select_decl (b, flags);
5817       if (scope == global_namespace)
5818         break;
5819     }
5820   return val;
5821 }
5822
5823 /* Combine prefer_type and namespaces_only into flags.  */
5824
5825 static int
5826 lookup_flags (prefer_type, namespaces_only)
5827   int prefer_type, namespaces_only;
5828 {
5829   if (namespaces_only)
5830     return LOOKUP_PREFER_NAMESPACES;
5831   if (prefer_type > 1)
5832     return LOOKUP_PREFER_TYPES;
5833   if (prefer_type > 0)
5834     return LOOKUP_PREFER_BOTH;
5835   return 0;
5836 }
5837
5838 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5839    ignore it or not.  Subroutine of lookup_name_real.  */
5840
5841 static tree
5842 qualify_lookup (val, flags)
5843      tree val;
5844      int flags;
5845 {
5846   if (val == NULL_TREE)
5847     return val;
5848   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5849     return val;
5850   if ((flags & LOOKUP_PREFER_TYPES)
5851       && (TREE_CODE (val) == TYPE_DECL
5852           || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5853               && DECL_CLASS_TEMPLATE_P (val))))
5854     return val;
5855   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5856     return NULL_TREE;
5857   return val;
5858 }
5859
5860 /* Any other BINDING overrides an implicit TYPENAME.  Warn about
5861    that.  */
5862
5863 static void
5864 warn_about_implicit_typename_lookup (typename, binding)
5865      tree typename;
5866      tree binding;
5867 {
5868   tree subtype = TREE_TYPE (TREE_TYPE (typename));
5869   tree name = DECL_NAME (typename);
5870
5871   if (! (TREE_CODE (binding) == TEMPLATE_DECL
5872          && CLASSTYPE_TEMPLATE_INFO (subtype)
5873          && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
5874       && ! (TREE_CODE (binding) == TYPE_DECL
5875             && same_type_p (TREE_TYPE (binding), subtype)))
5876     {
5877       cp_warning ("lookup of `%D' finds `%#D'",
5878                   name, binding);
5879       cp_warning ("  instead of `%D' from dependent base class",
5880                   typename);
5881       cp_warning ("  (use `typename %T::%D' if that's what you meant)",
5882                   constructor_name (current_class_type), name);
5883     }
5884 }
5885
5886 /* Look up NAME in the current binding level and its superiors in the
5887    namespace of variables, functions and typedefs.  Return a ..._DECL
5888    node of some kind representing its definition if there is only one
5889    such declaration, or return a TREE_LIST with all the overloaded
5890    definitions if there are many, or return 0 if it is undefined.
5891
5892    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5893    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5894    If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5895    Otherwise we prefer non-TYPE_DECLs.
5896
5897    If NONCLASS is non-zero, we don't look for the NAME in class scope,
5898    using IDENTIFIER_CLASS_VALUE.  */
5899
5900 static tree
5901 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
5902      tree name;
5903      int prefer_type, nonclass, namespaces_only;
5904 {
5905   tree t;
5906   tree val = NULL_TREE;
5907   int yylex = 0;
5908   tree from_obj = NULL_TREE;
5909   int flags;
5910   int val_is_implicit_typename = 0;
5911
5912   /* Hack: copy flag set by parser, if set. */
5913   if (only_namespace_names)
5914     namespaces_only = 1;
5915
5916   if (prefer_type == -2)
5917     {
5918       extern int looking_for_typename;
5919       tree type = NULL_TREE;
5920
5921       yylex = 1;
5922       prefer_type = looking_for_typename;
5923
5924       flags = lookup_flags (prefer_type, namespaces_only);
5925       /* If the next thing is '<', class templates are types. */
5926       if (looking_for_template)
5927         flags |= LOOKUP_TEMPLATES_EXPECTED;
5928
5929       /* std:: becomes :: for now.  */
5930       if (got_scope && got_scope == fake_std_node)
5931         got_scope = void_type_node;
5932
5933       if (got_scope)
5934         type = got_scope;
5935       else if (got_object != error_mark_node)
5936         type = got_object;
5937
5938       if (type)
5939         {
5940           if (type == error_mark_node)
5941             return error_mark_node;
5942           if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
5943             type = TREE_TYPE (type);
5944
5945           if (TYPE_P (type))
5946             type = complete_type (type);
5947
5948           if (TREE_CODE (type) == VOID_TYPE)
5949             type = global_namespace;
5950           if (TREE_CODE (type) == NAMESPACE_DECL)
5951             {
5952               val = make_node (CPLUS_BINDING);
5953               flags |= LOOKUP_COMPLAIN;
5954               if (!qualified_lookup_using_namespace (name, type, val, flags))
5955                 return NULL_TREE;
5956               val = select_decl (val, flags);
5957             }
5958           else if (! IS_AGGR_TYPE (type)
5959                    || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5960                    || TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM
5961                    || TREE_CODE (type) == TYPENAME_TYPE)
5962             /* Someone else will give an error about this if needed.  */
5963             val = NULL_TREE;
5964           else if (type == current_class_type)
5965             val = IDENTIFIER_CLASS_VALUE (name);
5966           else
5967             {
5968               val = lookup_member (type, name, 0, prefer_type);
5969               type_access_control (type, val);
5970
5971               /* Restore the containing TYPENAME_TYPE if we looked
5972                  through it before.  */
5973               if (got_scope && got_scope != type
5974                   && val && TREE_CODE (val) == TYPE_DECL
5975                   && TREE_CODE (TREE_TYPE (val)) == TYPENAME_TYPE)
5976                 TYPE_CONTEXT (TREE_TYPE (val)) = got_scope;
5977             }
5978         }
5979       else
5980         val = NULL_TREE;
5981
5982       if (got_scope)
5983         goto done;
5984       else if (got_object && val)
5985         {
5986           from_obj = val;
5987           val = NULL_TREE;
5988         }
5989     }
5990   else
5991     {
5992       flags = lookup_flags (prefer_type, namespaces_only);
5993       /* If we're not parsing, we need to complain. */
5994       flags |= LOOKUP_COMPLAIN;
5995     }
5996
5997   /* First, look in non-namespace scopes.  */
5998
5999   if (current_class_type == NULL_TREE)
6000     nonclass = 1;
6001
6002   for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
6003     {
6004       tree binding;
6005
6006       if (!LOCAL_BINDING_P (t) && nonclass)
6007         /* We're not looking for class-scoped bindings, so keep going.  */
6008         continue;
6009
6010       /* If this is the kind of thing we're looking for, we're done.  */
6011       if (qualify_lookup (BINDING_VALUE (t), flags))
6012         binding = BINDING_VALUE (t);
6013       else if ((flags & LOOKUP_PREFER_TYPES)
6014                && qualify_lookup (BINDING_TYPE (t), flags))
6015         binding = BINDING_TYPE (t);
6016       else
6017         binding = NULL_TREE;
6018
6019       /* Handle access control on types from enclosing or base classes.  */
6020       if (binding && ! yylex
6021           && BINDING_LEVEL (t) && BINDING_LEVEL (t)->parm_flag == 2)
6022         type_access_control (BINDING_LEVEL (t)->this_class, binding);
6023
6024       if (binding
6025           && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
6026         {
6027           if (val_is_implicit_typename && !yylex)
6028             warn_about_implicit_typename_lookup (val, binding);
6029           val = binding;
6030           val_is_implicit_typename
6031             = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
6032           if (!val_is_implicit_typename)
6033             break;
6034         }
6035     }
6036
6037   /* Now lookup in namespace scopes.  */
6038   if (!val || val_is_implicit_typename)
6039     {
6040       t = unqualified_namespace_lookup (name, flags, 0);
6041       if (t)
6042         {
6043           if (val_is_implicit_typename && !yylex)
6044             warn_about_implicit_typename_lookup (val, t);
6045           val = t;
6046         }
6047     }
6048
6049  done:
6050   if (val)
6051     {
6052       /* This should only warn about types used in qualified-ids.  */
6053       if (from_obj && from_obj != val)
6054         {
6055           if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
6056               && TREE_CODE (val) == TYPE_DECL
6057               && ! same_type_p (TREE_TYPE (from_obj), TREE_TYPE (val)))
6058             cp_pedwarn ("\
6059 lookup of `%D' in the scope of `%#T' (`%#D') \
6060 does not match lookup in the current scope (`%#D')",
6061                         name, got_object, from_obj, val);
6062
6063           /* We don't change val to from_obj if got_object depends on
6064              template parms because that breaks implicit typename for
6065              destructor calls.  */
6066           if (! uses_template_parms (got_object))
6067             val = from_obj;
6068         }
6069
6070       /* If we have a single function from a using decl, pull it out.  */
6071       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
6072         val = OVL_FUNCTION (val);
6073     }
6074   else if (from_obj)
6075     val = from_obj;
6076
6077   return val;
6078 }
6079
6080 tree
6081 lookup_name_nonclass (name)
6082      tree name;
6083 {
6084   return lookup_name_real (name, 0, 1, 0);
6085 }
6086
6087 tree
6088 lookup_function_nonclass (name, args)
6089      tree name;
6090      tree args;
6091 {
6092   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
6093 }
6094
6095 tree
6096 lookup_name_namespace_only (name)
6097      tree name;
6098 {
6099   /* type-or-namespace, nonclass, namespace_only */
6100   return lookup_name_real (name, 1, 1, 1);
6101 }
6102
6103 tree
6104 lookup_name (name, prefer_type)
6105      tree name;
6106      int prefer_type;
6107 {
6108   return lookup_name_real (name, prefer_type, 0, 0);
6109 }
6110
6111 /* Similar to `lookup_name' but look only in the innermost non-class
6112    binding level.  */
6113
6114 tree
6115 lookup_name_current_level (name)
6116      tree name;
6117 {
6118   struct binding_level *b;
6119   tree t = NULL_TREE;
6120
6121   b = current_binding_level;
6122   while (b->parm_flag == 2)
6123     b = b->level_chain;
6124
6125   if (b->namespace_p)
6126     {
6127       t = IDENTIFIER_NAMESPACE_VALUE (name);
6128
6129       /* extern "C" function() */
6130       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
6131         t = TREE_VALUE (t);
6132     }
6133   else if (IDENTIFIER_BINDING (name)
6134            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
6135     {
6136       while (1)
6137         {
6138           if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
6139             return IDENTIFIER_VALUE (name);
6140
6141           if (b->keep == 2)
6142             b = b->level_chain;
6143           else
6144             break;
6145         }
6146     }
6147
6148   return t;
6149 }
6150
6151 /* Like lookup_name_current_level, but for types.  */
6152
6153 tree
6154 lookup_type_current_level (name)
6155      tree name;
6156 {
6157   register tree t = NULL_TREE;
6158
6159   my_friendly_assert (! current_binding_level->namespace_p, 980716);
6160
6161   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
6162       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
6163     {
6164       struct binding_level *b = current_binding_level;
6165       while (1)
6166         {
6167           if (purpose_member (name, b->type_shadowed))
6168             return REAL_IDENTIFIER_TYPE_VALUE (name);
6169           if (b->keep == 2)
6170             b = b->level_chain;
6171           else
6172             break;
6173         }
6174     }
6175
6176   return t;
6177 }
6178
6179 void
6180 begin_only_namespace_names ()
6181 {
6182   only_namespace_names = 1;
6183 }
6184
6185 void
6186 end_only_namespace_names ()
6187 {
6188   only_namespace_names = 0;
6189 }
6190 \f
6191 /* Push the declarations of builtin types into the namespace.
6192    RID_INDEX is the index of the builtin type
6193    in the array RID_POINTERS.  NAME is the name used when looking
6194    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
6195
6196 void
6197 record_builtin_type (rid_index, name, type)
6198      enum rid rid_index;
6199      const char *name;
6200      tree type;
6201 {
6202   tree rname = NULL_TREE, tname = NULL_TREE;
6203   tree tdecl = NULL_TREE;
6204
6205   if ((int) rid_index < (int) RID_MAX)
6206     rname = ridpointers[(int) rid_index];
6207   if (name)
6208     tname = get_identifier (name);
6209
6210   TYPE_BUILT_IN (type) = 1;
6211
6212   if (tname)
6213     {
6214       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
6215       set_identifier_type_value (tname, NULL_TREE);
6216       if ((int) rid_index < (int) RID_MAX)
6217         /* Built-in types live in the global namespace. */
6218         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
6219     }
6220   if (rname != NULL_TREE)
6221     {
6222       if (tname != NULL_TREE)
6223         {
6224           set_identifier_type_value (rname, NULL_TREE);
6225           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
6226         }
6227       else
6228         {
6229           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
6230           set_identifier_type_value (rname, NULL_TREE);
6231         }
6232     }
6233 }
6234
6235 /* Record one of the standard Java types.
6236  * Declare it as having the given NAME.
6237  * If SIZE > 0, it is the size of one of the integral types;
6238  * otherwise it is the negative of the size of one of the other types.  */
6239
6240 static tree
6241 record_builtin_java_type (name, size)
6242      const char *name;
6243      int size;
6244 {
6245   tree type, decl;
6246   if (size > 0)
6247     type = make_signed_type (size);
6248   else if (size > -32)
6249     { /* "__java_char" or ""__java_boolean". */
6250       type = make_unsigned_type (-size);
6251       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6252     }
6253   else
6254     { /* "__java_float" or ""__java_double". */
6255       type = make_node (REAL_TYPE);
6256       TYPE_PRECISION (type) = - size;
6257       layout_type (type);
6258     }
6259   record_builtin_type (RID_MAX, name, type);
6260   decl = TYPE_NAME (type);
6261
6262   /* Suppress generate debug symbol entries for these types,
6263      since for normal C++ they are just clutter.
6264      However, push_lang_context undoes this if extern "Java" is seen. */
6265   DECL_IGNORED_P (decl) = 1;
6266
6267   TYPE_FOR_JAVA (type) = 1;
6268   return type;
6269 }
6270
6271 /* Push a type into the namespace so that the back-ends ignore it. */
6272
6273 static void
6274 record_unknown_type (type, name)
6275      tree type;
6276      const char *name;
6277 {
6278   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
6279   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
6280   DECL_IGNORED_P (decl) = 1;
6281   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6282   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
6283   TYPE_ALIGN (type) = 1;
6284   TYPE_USER_ALIGN (type) = 0;
6285   TYPE_MODE (type) = TYPE_MODE (void_type_node);
6286 }
6287
6288 /* An string for which we should create an IDENTIFIER_NODE at
6289    startup.  */
6290
6291 typedef struct predefined_identifier
6292 {
6293   /* The name of the identifier.  */
6294   const char *name;
6295   /* The place where the IDENTIFIER_NODE should be stored.  */
6296   tree *node;
6297   /* Non-zero if this is the name of a constructor or destructor.  */
6298   int ctor_or_dtor_p;
6299 } predefined_identifier;
6300
6301 /* Create all the predefined identifiers.  */
6302
6303 static void
6304 initialize_predefined_identifiers ()
6305 {
6306   struct predefined_identifier *pid;
6307
6308   /* A table of identifiers to create at startup.  */
6309   static predefined_identifier predefined_identifiers[] = {
6310     { "C++", &lang_name_cplusplus, 0 },
6311     { "C", &lang_name_c, 0 },
6312     { "Java", &lang_name_java, 0 },
6313     { CTOR_NAME, &ctor_identifier, 1 },
6314     { "__base_ctor", &base_ctor_identifier, 1 },
6315     { "__comp_ctor", &complete_ctor_identifier, 1 },
6316     { DTOR_NAME, &dtor_identifier, 1 },
6317     { "__comp_dtor", &complete_dtor_identifier, 1 },
6318     { "__base_dtor", &base_dtor_identifier, 1 },
6319     { "__deleting_dtor", &deleting_dtor_identifier, 1 },
6320     { VTABLE_DELTA2_NAME, &delta2_identifier, 0 },
6321     { VTABLE_DELTA_NAME, &delta_identifier, 0 },
6322     { IN_CHARGE_NAME, &in_charge_identifier, 0 },
6323     { VTABLE_INDEX_NAME, &index_identifier, 0 },
6324     { "nelts", &nelts_identifier, 0 },
6325     { THIS_NAME, &this_identifier, 0 },
6326     { VTABLE_PFN_NAME, &pfn_identifier, 0 },
6327     { "__pfn_or_delta2", &pfn_or_delta2_identifier, 0 },
6328     { "_vptr", &vptr_identifier, 0 },
6329     { "__vtt_parm", &vtt_parm_identifier, 0 },
6330     { "std", &std_identifier, 0 },
6331     { NULL, NULL, 0 }
6332   };
6333
6334   for (pid = predefined_identifiers; pid->name; ++pid)
6335     {
6336       *pid->node = get_identifier (pid->name);
6337       if (pid->ctor_or_dtor_p)
6338         IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
6339     }
6340 }
6341
6342 /* Create the predefined scalar types of C,
6343    and some nodes representing standard constants (0, 1, (void *)0).
6344    Initialize the global binding level.
6345    Make definitions for built-in primitive functions.  */
6346
6347 void
6348 init_decl_processing ()
6349 {
6350   tree fields[20];
6351
6352   /* Check to see that the user did not specify an invalid combination
6353      of command-line options.  */
6354   if (!flag_vtable_thunks)
6355     error ("the ABI requires vtable thunks");
6356
6357   /* Create all the identifiers we need.  */
6358   initialize_predefined_identifiers ();
6359
6360   /* Fill in back-end hooks.  */
6361   init_lang_status = &push_cp_function_context;
6362   free_lang_status = &pop_cp_function_context;
6363   mark_lang_status = &mark_cp_function_context;
6364   lang_safe_from_p = &c_safe_from_p;
6365   lang_dump_tree = &cp_dump_tree;
6366   lang_missing_noreturn_ok_p = &cp_missing_noreturn_ok_p;
6367
6368   cp_parse_init ();
6369   init_decl2 ();
6370   init_pt ();
6371
6372   /* Create the global variables.  */
6373   push_to_top_level ();
6374
6375   /* Enter the global namespace. */
6376   my_friendly_assert (global_namespace == NULL_TREE, 375);
6377   push_namespace (get_identifier ("::"));
6378   global_namespace = current_namespace;
6379   current_lang_name = NULL_TREE;
6380
6381   /* Adjust various flags based on command-line settings.  */
6382   if (! flag_permissive && ! pedantic)
6383     flag_pedantic_errors = 1;
6384   if (!flag_no_inline)
6385     {
6386       flag_inline_trees = 1;
6387       flag_no_inline = 1;
6388     }
6389   if (flag_inline_functions)
6390     {
6391       flag_inline_trees = 2;
6392       flag_inline_functions = 0;
6393     }
6394
6395   /* In C++, we never create builtin functions whose name does not
6396      begin with `__'.  Users should be using headers to get prototypes
6397      in C++.  It would be nice if we could warn when `-fbuiltin' is
6398      used explicitly, but we do not have that information.  */
6399   flag_no_builtin = 1;
6400
6401   /* Initially, C.  */
6402   current_lang_name = lang_name_c;
6403
6404   current_function_decl = NULL_TREE;
6405   current_binding_level = NULL_BINDING_LEVEL;
6406   free_binding_level = NULL_BINDING_LEVEL;
6407
6408   build_common_tree_nodes (flag_signed_char);
6409
6410   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6411   TREE_TYPE (error_mark_list) = error_mark_node;
6412
6413   /* Make the binding_level structure for global names.  */
6414   pushlevel (0);
6415   global_binding_level = current_binding_level;
6416   /* The global level is the namespace level of ::.  */
6417   NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6418   declare_namespace_level ();
6419
6420   /* Create the `std' namespace.  */
6421   if (flag_honor_std)
6422     {
6423       push_namespace (std_identifier);
6424       std_node = current_namespace;
6425       pop_namespace ();
6426       fake_std_node = error_mark_node;
6427     }
6428   else
6429     {
6430       fake_std_node = build_decl (NAMESPACE_DECL,
6431                                   std_identifier,
6432                                   void_type_node);
6433       pushdecl (fake_std_node);
6434     }
6435
6436   c_common_nodes_and_builtins ();
6437
6438   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6439   java_short_type_node = record_builtin_java_type ("__java_short", 16);
6440   java_int_type_node = record_builtin_java_type ("__java_int", 32);
6441   java_long_type_node = record_builtin_java_type ("__java_long", 64);
6442   java_float_type_node = record_builtin_java_type ("__java_float", -32);
6443   java_double_type_node = record_builtin_java_type ("__java_double", -64);
6444   java_char_type_node = record_builtin_java_type ("__java_char", -16);
6445   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6446
6447   integer_two_node = build_int_2 (2, 0);
6448   TREE_TYPE (integer_two_node) = integer_type_node;
6449   integer_three_node = build_int_2 (3, 0);
6450   TREE_TYPE (integer_three_node) = integer_type_node;
6451
6452   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6453   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6454   TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6455   TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6456   TYPE_PRECISION (boolean_type_node) = 1;
6457   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6458   boolean_false_node = build_int_2 (0, 0);
6459   TREE_TYPE (boolean_false_node) = boolean_type_node;
6460   boolean_true_node = build_int_2 (1, 0);
6461   TREE_TYPE (boolean_true_node) = boolean_type_node;
6462
6463   signed_size_zero_node = build_int_2 (0, 0);
6464   TREE_TYPE (signed_size_zero_node) = make_signed_type (TYPE_PRECISION (sizetype));
6465
6466   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6467
6468 #if 0
6469   record_builtin_type (RID_MAX, NULL_PTR, string_type_node);
6470 #endif
6471
6472   delta_type_node = ptrdiff_type_node;
6473   vtable_index_type = ptrdiff_type_node;
6474
6475   vtt_parm_type = build_pointer_type (const_ptr_type_node);
6476   lang_type_promotes_to = convert_type_from_ellipsis;
6477
6478   void_ftype_ptr
6479     = build_exception_variant (void_ftype_ptr, empty_except_spec);
6480
6481   /* C++ extensions */
6482
6483   unknown_type_node = make_node (UNKNOWN_TYPE);
6484   record_unknown_type (unknown_type_node, "unknown type");
6485
6486   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
6487   TREE_TYPE (unknown_type_node) = unknown_type_node;
6488
6489   TREE_TYPE (null_node) = type_for_size (POINTER_SIZE, 0);
6490
6491   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6492      result.  */
6493   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6494   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6495
6496   if (flag_vtable_thunks)
6497     {
6498       /* Make sure we get a unique function type, so we can give
6499          its pointer type a name.  (This wins for gdb.) */
6500       tree vfunc_type = make_node (FUNCTION_TYPE);
6501       TREE_TYPE (vfunc_type) = integer_type_node;
6502       TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6503       layout_type (vfunc_type);
6504
6505       vtable_entry_type = build_pointer_type (vfunc_type);
6506     }
6507   else
6508     {
6509       vtable_entry_type = make_aggr_type (RECORD_TYPE);
6510       fields[0] = build_decl (FIELD_DECL, delta_identifier,
6511                               delta_type_node);
6512       fields[1] = build_decl (FIELD_DECL, index_identifier,
6513                               delta_type_node);
6514       fields[2] = build_decl (FIELD_DECL, pfn_identifier,
6515                               ptr_type_node);
6516       finish_builtin_type (vtable_entry_type, VTBL_PTR_TYPE, fields, 2,
6517                            double_type_node);
6518
6519       /* Make this part of an invisible union.  */
6520       fields[3] = copy_node (fields[2]);
6521       TREE_TYPE (fields[3]) = delta_type_node;
6522       DECL_NAME (fields[3]) = delta2_identifier;
6523       DECL_MODE (fields[3]) = TYPE_MODE (delta_type_node);
6524       DECL_SIZE (fields[3]) = TYPE_SIZE (delta_type_node);
6525       DECL_SIZE_UNIT (fields[3]) = TYPE_SIZE_UNIT (delta_type_node);
6526       TREE_UNSIGNED (fields[3]) = 0;
6527       TREE_CHAIN (fields[2]) = fields[3];
6528       vtable_entry_type = build_qualified_type (vtable_entry_type,
6529                                                 TYPE_QUAL_CONST);
6530     }
6531   record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6532
6533   vtbl_type_node
6534     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6535   layout_type (vtbl_type_node);
6536   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6537   record_builtin_type (RID_MAX, NULL_PTR, vtbl_type_node);
6538   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6539   layout_type (vtbl_ptr_type_node);
6540   record_builtin_type (RID_MAX, NULL_PTR, vtbl_ptr_type_node);
6541
6542   push_namespace (get_identifier ("__cxxabiv1"));
6543   abi_node = current_namespace;
6544   pop_namespace ();
6545
6546   global_type_node = make_node (LANG_TYPE);
6547   record_unknown_type (global_type_node, "global type");
6548
6549   /* Now, C++.  */
6550   current_lang_name = lang_name_cplusplus;
6551
6552   {
6553     tree bad_alloc_type_node, newtype, deltype;
6554     if (flag_honor_std)
6555       push_namespace (std_identifier);
6556     bad_alloc_type_node = xref_tag
6557       (class_type_node, get_identifier ("bad_alloc"), 1);
6558     if (flag_honor_std)
6559       pop_namespace ();
6560     newtype = build_exception_variant
6561       (ptr_ftype_sizetype, add_exception_specifier (NULL_TREE, bad_alloc_type_node, -1));
6562     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6563     push_cp_library_fn (NEW_EXPR, newtype);
6564     push_cp_library_fn (VEC_NEW_EXPR, newtype);
6565     global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
6566     push_cp_library_fn (VEC_DELETE_EXPR, deltype);
6567   }
6568
6569   abort_fndecl
6570     = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype);
6571
6572   /* Perform other language dependent initializations.  */
6573   init_class_processing ();
6574   init_init_processing ();
6575   init_search_processing ();
6576   init_rtti_processing ();
6577
6578   if (flag_exceptions)
6579     init_exception_processing ();
6580
6581   if (! supports_one_only ())
6582     flag_weak = 0;
6583
6584   /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__.  */
6585   function_id_node = get_identifier ("__FUNCTION__");
6586   pretty_function_id_node = get_identifier ("__PRETTY_FUNCTION__");
6587   func_id_node = get_identifier ("__func__");
6588
6589   make_fname_decl = cp_make_fname_decl;
6590   declare_function_name ();
6591
6592   /* Prepare to check format strings against argument lists.  */
6593   init_function_format_info ();
6594
6595   /* Show we use EH for cleanups.  */
6596   using_eh_for_cleanups ();
6597
6598   valid_lang_attribute = cp_valid_lang_attribute;
6599
6600   /* Maintain consistency.  Perhaps we should just complain if they
6601      say -fwritable-strings?  */
6602   if (flag_writable_strings)
6603     flag_const_strings = 0;
6604
6605   /* Add GC roots for all of our global variables.  */
6606   ggc_add_tree_root (c_global_trees, sizeof c_global_trees / sizeof(tree));
6607   ggc_add_tree_root (cp_global_trees, sizeof cp_global_trees / sizeof(tree));
6608   ggc_add_tree_root (&integer_three_node, 1);
6609   ggc_add_tree_root (&integer_two_node, 1);
6610   ggc_add_tree_root (&signed_size_zero_node, 1);
6611   ggc_add_tree_root (&size_one_node, 1);
6612   ggc_add_tree_root (&size_zero_node, 1);
6613   ggc_add_root (&global_binding_level, 1, sizeof global_binding_level,
6614                 mark_binding_level);
6615   ggc_add_root (&scope_chain, 1, sizeof scope_chain, &mark_saved_scope);
6616   ggc_add_tree_root (&static_ctors, 1);
6617   ggc_add_tree_root (&static_dtors, 1);
6618   ggc_add_tree_root (&lastiddecl, 1);
6619
6620   ggc_add_tree_root (&last_function_parm_tags, 1);
6621   ggc_add_tree_root (&current_function_return_value, 1);
6622   ggc_add_tree_root (&current_function_parm_tags, 1);
6623   ggc_add_tree_root (&last_function_parms, 1);
6624   ggc_add_tree_root (&error_mark_list, 1);
6625
6626   ggc_add_tree_root (&global_namespace, 1);
6627   ggc_add_tree_root (&global_type_node, 1);
6628   ggc_add_tree_root (&anonymous_namespace_name, 1);
6629
6630   ggc_add_tree_root (&got_object, 1);
6631   ggc_add_tree_root (&got_scope, 1);
6632
6633   ggc_add_tree_root (&current_lang_name, 1);
6634   ggc_add_tree_root (&static_aggregates, 1);
6635   ggc_add_tree_root (&free_bindings, 1);
6636 }
6637
6638 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6639    decl, NAME is the initialization string and TYPE_DEP indicates whether
6640    NAME depended on the type of the function. We make use of that to detect
6641    __PRETTY_FUNCTION__ inside a template fn.  Because we build a tree for
6642    the function before emitting any of it, we don't need to treat the
6643    VAR_DECL specially. We can decide whether to emit it later, if it was
6644    used.  */
6645
6646 static tree
6647 cp_make_fname_decl (id, name, type_dep)
6648      tree id;
6649      const char *name;
6650      int type_dep;
6651 {
6652   tree decl, type, init;
6653   size_t length = strlen (name);
6654   tree domain = NULL_TREE;
6655
6656   if (!processing_template_decl)
6657     type_dep = 0;
6658   if (!type_dep)
6659     domain = build_index_type (size_int (length));
6660
6661   type =  build_cplus_array_type
6662           (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
6663            domain);
6664
6665   decl = build_decl (VAR_DECL, id, type);
6666   TREE_STATIC (decl) = 1;
6667   TREE_READONLY (decl) = 1;
6668   DECL_SOURCE_LINE (decl) = 0;
6669   DECL_ARTIFICIAL (decl) = 1;
6670   DECL_IN_SYSTEM_HEADER (decl) = 1;
6671   DECL_IGNORED_P (decl) = 1;
6672   pushdecl (decl);
6673   if (processing_template_decl)
6674     decl = push_template_decl (decl);
6675   if (type_dep)
6676     {
6677       init = build (FUNCTION_NAME, type);
6678       DECL_PRETTY_FUNCTION_P (decl) = 1;
6679     }
6680   else
6681     {
6682       init = build_string (length + 1, name);
6683       TREE_TYPE (init) = type;
6684     }
6685   DECL_INITIAL (decl) = init;
6686   cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
6687
6688   /* We will have to make sure we only emit this, if it is actually used. */
6689   return decl;
6690 }
6691
6692 /* Entry point for the benefit of c_common_nodes_and_builtins.
6693
6694    Make a definition for a builtin function named NAME and whose data type
6695    is TYPE.  TYPE should be a function type with argument types.
6696
6697    CLASS and CODE tell later passes how to compile calls to this function.
6698    See tree.h for possible values.
6699
6700    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6701    the name to be called if we can't opencode the function.  */
6702
6703 tree
6704 builtin_function (name, type, code, class, libname)
6705      const char *name;
6706      tree type;
6707      int code;
6708      enum built_in_class class;
6709      const char *libname;
6710 {
6711   tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
6712   DECL_BUILT_IN_CLASS (decl) = class;
6713   DECL_FUNCTION_CODE (decl) = code;
6714
6715   my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 392);
6716
6717   /* All builtins that don't begin with an `_' should go in the `std'
6718      namespace.  */
6719   if (flag_honor_std && name[0] != '_')
6720     {
6721       push_namespace (std_identifier);
6722       DECL_CONTEXT (decl) = std_node;
6723     }
6724   pushdecl (decl);
6725   if (flag_honor_std && name[0] != '_')
6726     pop_namespace ();
6727
6728   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6729      we cannot change DECL_ASSEMBLER_NAME until we have installed this
6730      function in the namespace.  */
6731   if (libname)
6732     SET_DECL_ASSEMBLER_NAME (decl, get_identifier (libname));
6733   make_decl_rtl (decl, NULL);
6734
6735   /* Warn if a function in the namespace for users
6736      is used without an occasion to consider it declared.  */
6737   if (name[0] != '_' || name[1] != '_')
6738     DECL_ANTICIPATED (decl) = 1;
6739
6740   return decl;
6741 }
6742
6743 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
6744    function.  Not called directly.  */
6745
6746 static tree
6747 build_library_fn_1 (name, operator_code, type)
6748      tree name;
6749      enum tree_code operator_code;
6750      tree type;
6751 {
6752   tree fn = build_lang_decl (FUNCTION_DECL, name, type);
6753   DECL_EXTERNAL (fn) = 1;
6754   TREE_PUBLIC (fn) = 1;
6755   DECL_ARTIFICIAL (fn) = 1;
6756   TREE_NOTHROW (fn) = 1;
6757   SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
6758   SET_DECL_LANGUAGE (fn, lang_c);
6759   return fn;
6760 }
6761
6762 /* Returns the _DECL for a library function with C linkage.
6763    We assume that such functions never throw; if this is incorrect,
6764    callers should unset TREE_NOTHROW.  */
6765
6766 tree
6767 build_library_fn (name, type)
6768      tree name;
6769      tree type;
6770 {
6771   return build_library_fn_1 (name, ERROR_MARK, type);
6772 }
6773
6774 /* Returns the _DECL for a library function with C++ linkage.  */
6775
6776 static tree
6777 build_cp_library_fn (name, operator_code, type)
6778      tree name;
6779      enum tree_code operator_code;
6780      tree type;
6781 {
6782   tree fn = build_library_fn_1 (name, operator_code, type);
6783   TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
6784   DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
6785   SET_DECL_LANGUAGE (fn, lang_cplusplus);
6786   set_mangled_name_for_decl (fn);
6787   return fn;
6788 }
6789
6790 /* Like build_library_fn, but takes a C string instead of an
6791    IDENTIFIER_NODE.  */
6792
6793 tree
6794 build_library_fn_ptr (name, type)
6795      const char *name;
6796      tree type;
6797 {
6798   return build_library_fn (get_identifier (name), type);
6799 }
6800
6801 /* Like build_cp_library_fn, but takes a C string instead of an
6802    IDENTIFIER_NODE.  */
6803
6804 tree
6805 build_cp_library_fn_ptr (name, type)
6806      const char *name;
6807      tree type;
6808 {
6809   return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
6810 }
6811
6812 /* Like build_library_fn, but also pushes the function so that we will
6813    be able to find it via IDENTIFIER_GLOBAL_VALUE.  */
6814
6815 tree
6816 push_library_fn (name, type)
6817      tree name, type;
6818 {
6819   tree fn = build_library_fn (name, type);
6820   pushdecl_top_level (fn);
6821   return fn;
6822 }
6823
6824 /* Like build_cp_library_fn, but also pushes the function so that it
6825    will be found by normal lookup.  */
6826
6827 static tree
6828 push_cp_library_fn (operator_code, type)
6829      enum tree_code operator_code;
6830      tree type;
6831 {
6832   tree fn = build_cp_library_fn (ansi_opname (operator_code),
6833                                  operator_code,
6834                                  type);
6835   pushdecl (fn);
6836   return fn;
6837 }
6838
6839 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
6840    a FUNCTION_TYPE.  */
6841
6842 tree
6843 push_void_library_fn (name, parmtypes)
6844      tree name, parmtypes;
6845 {
6846   tree type = build_function_type (void_type_node, parmtypes);
6847   return push_library_fn (name, type);
6848 }
6849
6850 /* Like push_library_fn, but also note that this function throws
6851    and does not return.  Used for __throw_foo and the like.  */
6852
6853 tree
6854 push_throw_library_fn (name, type)
6855      tree name, type;
6856 {
6857   tree fn = push_library_fn (name, type);
6858   TREE_THIS_VOLATILE (fn) = 1;
6859   TREE_NOTHROW (fn) = 0;
6860   return fn;
6861 }
6862 \f
6863 /* When we call finish_struct for an anonymous union, we create
6864    default copy constructors and such.  But, an anonymous union
6865    shouldn't have such things; this function undoes the damage to the
6866    anonymous union type T.
6867
6868    (The reason that we create the synthesized methods is that we don't
6869    distinguish `union { int i; }' from `typedef union { int i; } U'.
6870    The first is an anonymous union; the second is just an ordinary
6871    union type.)  */
6872
6873 void
6874 fixup_anonymous_aggr (t)
6875      tree t;
6876 {
6877   tree *q;
6878
6879   /* Wipe out memory of synthesized methods */
6880   TYPE_HAS_CONSTRUCTOR (t) = 0;
6881   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6882   TYPE_HAS_INIT_REF (t) = 0;
6883   TYPE_HAS_CONST_INIT_REF (t) = 0;
6884   TYPE_HAS_ASSIGN_REF (t) = 0;
6885   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6886
6887   /* Splice the implicitly generated functions out of the TYPE_METHODS
6888      list.  */
6889   q = &TYPE_METHODS (t);
6890   while (*q)
6891     {
6892       if (DECL_ARTIFICIAL (*q))
6893         *q = TREE_CHAIN (*q);
6894       else
6895         q = &TREE_CHAIN (*q);
6896     }
6897
6898   /* ISO C++ 9.5.3.  Anonymous unions may not have function members.  */
6899   if (TYPE_METHODS (t))
6900     cp_error_at ("an anonymous union cannot have function members", t);
6901
6902   /* Anonymous aggregates cannot have fields with ctors, dtors or complex
6903      assignment operators (because they cannot have these methods themselves).
6904      For anonymous unions this is already checked because they are not allowed
6905      in any union, otherwise we have to check it.  */
6906   if (TREE_CODE (t) != UNION_TYPE)
6907     {
6908       tree field, type;
6909
6910       for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
6911         if (TREE_CODE (field) == FIELD_DECL)
6912           {
6913             type = TREE_TYPE (field);
6914             if (CLASS_TYPE_P (type))
6915               {
6916                 if (TYPE_NEEDS_CONSTRUCTING (type))
6917                   cp_error_at ("member %#D' with constructor not allowed in anonymous aggregate",
6918                                field);
6919                 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
6920                   cp_error_at ("member %#D' with destructor not allowed in anonymous aggregate",
6921                                field);
6922                 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type))
6923                   cp_error_at ("member %#D' with copy assignment operator not allowed in anonymous aggregate",
6924                                field);
6925               }
6926           }
6927     }
6928 }
6929
6930 /* Make sure that a declaration with no declarator is well-formed, i.e.
6931    just defines a tagged type or anonymous union.
6932
6933    Returns the type defined, if any.  */
6934
6935 tree
6936 check_tag_decl (declspecs)
6937      tree declspecs;
6938 {
6939   int found_type = 0;
6940   int saw_friend = 0;
6941   int saw_typedef = 0;
6942   tree ob_modifier = NULL_TREE;
6943   register tree link;
6944   register tree t = NULL_TREE;
6945
6946   for (link = declspecs; link; link = TREE_CHAIN (link))
6947     {
6948       register tree value = TREE_VALUE (link);
6949
6950       if (TYPE_P (value)
6951           || TREE_CODE (value) == TYPE_DECL
6952           || (TREE_CODE (value) == IDENTIFIER_NODE
6953               && IDENTIFIER_GLOBAL_VALUE (value)
6954               && TREE_CODE (IDENTIFIER_GLOBAL_VALUE (value)) == TYPE_DECL))
6955         {
6956           ++found_type;
6957
6958           if (found_type == 2 && TREE_CODE (value) == IDENTIFIER_NODE)
6959             {
6960               if (! in_system_header)
6961                 cp_pedwarn ("redeclaration of C++ built-in type `%T'", value);
6962               return NULL_TREE;
6963             }
6964
6965           if (TYPE_P (value)
6966               && ((TREE_CODE (value) != TYPENAME_TYPE && IS_AGGR_TYPE (value))
6967                   || TREE_CODE (value) == ENUMERAL_TYPE))
6968             {
6969               my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
6970               t = value;
6971             }
6972         }
6973       else if (value == ridpointers[(int) RID_TYPEDEF])
6974         saw_typedef = 1;
6975       else if (value == ridpointers[(int) RID_FRIEND])
6976         {
6977           if (current_class_type == NULL_TREE
6978               || current_scope () != current_class_type)
6979             ob_modifier = value;
6980           else
6981             saw_friend = 1;
6982         }
6983       else if (value == ridpointers[(int) RID_STATIC]
6984                || value == ridpointers[(int) RID_EXTERN]
6985                || value == ridpointers[(int) RID_AUTO]
6986                || value == ridpointers[(int) RID_REGISTER]
6987                || value == ridpointers[(int) RID_INLINE]
6988                || value == ridpointers[(int) RID_VIRTUAL]
6989                || value == ridpointers[(int) RID_CONST]
6990                || value == ridpointers[(int) RID_VOLATILE]
6991                || value == ridpointers[(int) RID_EXPLICIT])
6992         ob_modifier = value;
6993     }
6994
6995   if (found_type > 1)
6996     error ("multiple types in one declaration");
6997
6998   if (t == NULL_TREE && ! saw_friend)
6999     pedwarn ("declaration does not declare anything");
7000
7001   /* Check for an anonymous union.  */
7002   else if (t && IS_AGGR_TYPE_CODE (TREE_CODE (t))
7003            && TYPE_ANONYMOUS_P (t))
7004     {
7005       /* 7/3 In a simple-declaration, the optional init-declarator-list
7006          can be omitted only when declaring a class (clause 9) or
7007          enumeration (7.2), that is, when the decl-specifier-seq contains
7008          either a class-specifier, an elaborated-type-specifier with
7009          a class-key (9.1), or an enum-specifier.  In these cases and
7010          whenever a class-specifier or enum-specifier is present in the
7011          decl-specifier-seq, the identifiers in these specifiers are among
7012          the names being declared by the declaration (as class-name,
7013          enum-names, or enumerators, depending on the syntax).  In such
7014          cases, and except for the declaration of an unnamed bit-field (9.6),
7015          the decl-specifier-seq shall introduce one or more names into the
7016          program, or shall redeclare a name introduced by a previous
7017          declaration.  [Example:
7018              enum { };            // ill-formed
7019              typedef class { };   // ill-formed
7020          --end example]  */
7021       if (saw_typedef)
7022         {
7023           error ("Missing type-name in typedef-declaration.");
7024           return NULL_TREE;
7025         }
7026       /* Anonymous unions are objects, so they can have specifiers.  */;
7027       SET_ANON_AGGR_TYPE_P (t);
7028
7029       if (TREE_CODE (t) != UNION_TYPE && pedantic && ! in_system_header)
7030         pedwarn ("ISO C++ prohibits anonymous structs");
7031     }
7032
7033   else if (ob_modifier)
7034     {
7035       if (ob_modifier == ridpointers[(int) RID_INLINE]
7036           || ob_modifier == ridpointers[(int) RID_VIRTUAL])
7037         cp_error ("`%D' can only be specified for functions", ob_modifier);
7038       else if (ob_modifier == ridpointers[(int) RID_FRIEND])
7039         cp_error ("`%D' can only be specified inside a class", ob_modifier);
7040       else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
7041         cp_error ("`%D' can only be specified for constructors",
7042                   ob_modifier);
7043       else
7044         cp_error ("`%D' can only be specified for objects and functions",
7045                   ob_modifier);
7046     }
7047
7048   return t;
7049 }
7050
7051 /* Called when a declaration is seen that contains no names to declare.
7052    If its type is a reference to a structure, union or enum inherited
7053    from a containing scope, shadow that tag name for the current scope
7054    with a forward reference.
7055    If its type defines a new named structure or union
7056    or defines an enum, it is valid but we need not do anything here.
7057    Otherwise, it is an error.
7058
7059    C++: may have to grok the declspecs to learn about static,
7060    complain for anonymous unions.  */
7061
7062 void
7063 shadow_tag (declspecs)
7064      tree declspecs;
7065 {
7066   tree t = check_tag_decl (declspecs);
7067
7068   if (t)
7069     maybe_process_partial_specialization (t);
7070
7071   /* This is where the variables in an anonymous union are
7072      declared.  An anonymous union declaration looks like:
7073      union { ... } ;
7074      because there is no declarator after the union, the parser
7075      sends that declaration here.  */
7076   if (t && ANON_AGGR_TYPE_P (t))
7077     {
7078       fixup_anonymous_aggr (t);
7079
7080       if (TYPE_FIELDS (t))
7081         {
7082           tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
7083                                       NULL_TREE);
7084           finish_anon_union (decl);
7085         }
7086     }
7087 }
7088 \f
7089 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
7090
7091 tree
7092 groktypename (typename)
7093      tree typename;
7094 {
7095   if (TREE_CODE (typename) != TREE_LIST)
7096     return typename;
7097   return grokdeclarator (TREE_VALUE (typename),
7098                          TREE_PURPOSE (typename),
7099                          TYPENAME, 0, NULL_TREE);
7100 }
7101
7102 /* Decode a declarator in an ordinary declaration or data definition.
7103    This is called as soon as the type information and variable name
7104    have been parsed, before parsing the initializer if any.
7105    Here we create the ..._DECL node, fill in its type,
7106    and put it on the list of decls for the current context.
7107    The ..._DECL node is returned as the value.
7108
7109    Exception: for arrays where the length is not specified,
7110    the type is left null, to be filled in by `cp_finish_decl'.
7111
7112    Function definitions do not come here; they go to start_function
7113    instead.  However, external and forward declarations of functions
7114    do go through here.  Structure field declarations are done by
7115    grokfield and not through here.  */
7116
7117 tree
7118 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
7119      tree declarator, declspecs;
7120      int initialized;
7121      tree attributes, prefix_attributes;
7122 {
7123   register tree decl;
7124   register tree type, tem;
7125   tree context;
7126   extern int have_extern_spec;
7127   extern int used_extern_spec;
7128   tree attrlist;
7129
7130 #if 0
7131   /* See code below that used this.  */
7132   int init_written = initialized;
7133 #endif
7134
7135   /* This should only be done once on the top most decl.  */
7136   if (have_extern_spec && !used_extern_spec)
7137     {
7138       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"),
7139                              declspecs);
7140       used_extern_spec = 1;
7141     }
7142
7143   if (attributes || prefix_attributes)
7144     attrlist = build_tree_list (attributes, prefix_attributes);
7145   else
7146     attrlist = NULL_TREE;
7147
7148   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
7149                          attrlist);
7150
7151   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
7152     return NULL_TREE;
7153
7154   type = TREE_TYPE (decl);
7155
7156   if (type == error_mark_node)
7157     return NULL_TREE;
7158
7159   context = DECL_CONTEXT (decl);
7160
7161   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
7162       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
7163     {
7164       /* When parsing the initializer, lookup should use the object's
7165          namespace. */
7166       push_decl_namespace (context);
7167     }
7168
7169   /* We are only interested in class contexts, later. */
7170   if (context && TREE_CODE (context) == NAMESPACE_DECL)
7171     context = NULL_TREE;
7172
7173   if (initialized)
7174     /* Is it valid for this decl to have an initializer at all?
7175        If not, set INITIALIZED to zero, which will indirectly
7176        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7177     switch (TREE_CODE (decl))
7178       {
7179       case TYPE_DECL:
7180         /* typedef foo = bar  means give foo the same type as bar.
7181            We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
7182            Any other case of an initialization in a TYPE_DECL is an error.  */
7183         if (pedantic || list_length (declspecs) > 1)
7184           {
7185             cp_error ("typedef `%D' is initialized", decl);
7186             initialized = 0;
7187           }
7188         break;
7189
7190       case FUNCTION_DECL:
7191         cp_error ("function `%#D' is initialized like a variable", decl);
7192         initialized = 0;
7193         break;
7194
7195       default:
7196         break;
7197       }
7198
7199   if (initialized)
7200     {
7201       if (! toplevel_bindings_p ()
7202           && DECL_EXTERNAL (decl))
7203         cp_warning ("declaration of `%#D' has `extern' and is initialized",
7204                     decl);
7205       DECL_EXTERNAL (decl) = 0;
7206       if (toplevel_bindings_p ())
7207         TREE_STATIC (decl) = 1;
7208
7209       /* Tell `pushdecl' this is an initialized decl
7210          even though we don't yet have the initializer expression.
7211          Also tell `cp_finish_decl' it may store the real initializer.  */
7212       DECL_INITIAL (decl) = error_mark_node;
7213     }
7214
7215 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
7216   SET_DEFAULT_DECL_ATTRIBUTES (decl, attributes);
7217 #endif
7218
7219   /* Set attributes here so if duplicate decl, will have proper attributes.  */
7220   cplus_decl_attributes (decl, attributes, prefix_attributes);
7221
7222   if (context && COMPLETE_TYPE_P (complete_type (context)))
7223     {
7224       push_nested_class (context, 2);
7225
7226       if (TREE_CODE (decl) == VAR_DECL)
7227         {
7228           tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
7229           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
7230             cp_error ("`%#D' is not a static member of `%#T'", decl, context);
7231           else
7232             {
7233               if (DECL_CONTEXT (field) != context)
7234                 {
7235                   cp_pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
7236                               DECL_CONTEXT (field), DECL_NAME (decl),
7237                               context, DECL_NAME (decl));
7238                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
7239                 }
7240               /* Static data member are tricky; an in-class initialization
7241                  still doesn't provide a definition, so the in-class
7242                  declaration will have DECL_EXTERNAL set, but will have an
7243                  initialization.  Thus, duplicate_decls won't warn
7244                  about this situation, and so we check here.  */
7245               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
7246                 cp_error ("duplicate initialization of %D", decl);
7247               if (duplicate_decls (decl, field))
7248                 decl = field;
7249             }
7250         }
7251       else
7252         {
7253           tree field = check_classfn (context, decl);
7254           if (field && duplicate_decls (decl, field))
7255             decl = field;
7256         }
7257
7258       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
7259       DECL_IN_AGGR_P (decl) = 0;
7260       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
7261           || CLASSTYPE_TEMPLATE_INSTANTIATION (context))
7262         {
7263           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
7264           /* [temp.expl.spec] An explicit specialization of a static data
7265              member of a template is a definition if the declaration
7266              includes an initializer; otherwise, it is a declaration.
7267
7268              We check for processing_specialization so this only applies
7269              to the new specialization syntax.  */
7270           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
7271             DECL_EXTERNAL (decl) = 1;
7272         }
7273
7274       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
7275         cp_pedwarn ("declaration of `%#D' outside of class is not definition",
7276                     decl);
7277     }
7278
7279   /* Enter this declaration into the symbol table.  */
7280   tem = maybe_push_decl (decl);
7281
7282   if (processing_template_decl)
7283     tem = push_template_decl (tem);
7284
7285 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7286   /* Tell the back-end to use or not use .common as appropriate.  If we say
7287      -fconserve-space, we want this to save .data space, at the expense of
7288      wrong semantics.  If we say -fno-conserve-space, we want this to
7289      produce errors about redefs; to do this we force variables into the
7290      data segment.  */
7291   DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
7292 #endif
7293
7294   if (! processing_template_decl)
7295     start_decl_1 (tem);
7296
7297   return tem;
7298 }
7299
7300 void
7301 start_decl_1 (decl)
7302      tree decl;
7303 {
7304   tree type = TREE_TYPE (decl);
7305   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
7306
7307   if (type == error_mark_node)
7308     return;
7309
7310   maybe_push_cleanup_level (type);
7311
7312   if (initialized)
7313     /* Is it valid for this decl to have an initializer at all?
7314        If not, set INITIALIZED to zero, which will indirectly
7315        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7316     {
7317       /* Don't allow initializations for incomplete types except for
7318          arrays which might be completed by the initialization.  */
7319       if (COMPLETE_TYPE_P (complete_type (type)))
7320         ;                       /* A complete type is ok.  */
7321       else if (TREE_CODE (type) != ARRAY_TYPE)
7322         {
7323           cp_error ("variable `%#D' has initializer but incomplete type",
7324                     decl);
7325           initialized = 0;
7326           type = TREE_TYPE (decl) = error_mark_node;
7327         }
7328       else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7329         {
7330           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
7331             cp_error ("elements of array `%#D' have incomplete type", decl);
7332           /* else we already gave an error in start_decl.  */
7333           initialized = 0;
7334         }
7335     }
7336
7337   if (!initialized
7338       && TREE_CODE (decl) != TYPE_DECL
7339       && TREE_CODE (decl) != TEMPLATE_DECL
7340       && type != error_mark_node
7341       && IS_AGGR_TYPE (type)
7342       && ! DECL_EXTERNAL (decl))
7343     {
7344       if ((! processing_template_decl || ! uses_template_parms (type))
7345           && !COMPLETE_TYPE_P (complete_type (type)))
7346         {
7347           cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
7348                  decl);
7349           /* Change the type so that assemble_variable will give
7350              DECL an rtl we can live with: (mem (const_int 0)).  */
7351           type = TREE_TYPE (decl) = error_mark_node;
7352         }
7353       else
7354         {
7355           /* If any base type in the hierarchy of TYPE needs a constructor,
7356              then we set initialized to 1.  This way any nodes which are
7357              created for the purposes of initializing this aggregate
7358              will live as long as it does.  This is necessary for global
7359              aggregates which do not have their initializers processed until
7360              the end of the file.  */
7361           initialized = TYPE_NEEDS_CONSTRUCTING (type);
7362         }
7363     }
7364
7365   if (! initialized)
7366     DECL_INITIAL (decl) = NULL_TREE;
7367 }
7368
7369 /* Handle initialization of references.
7370    These three arguments are from `cp_finish_decl', and have the
7371    same meaning here that they do there.
7372
7373    Quotes on semantics can be found in ARM 8.4.3.  */
7374
7375 static tree
7376 grok_reference_init (decl, type, init)
7377      tree decl, type, init;
7378 {
7379   tree tmp;
7380
7381   if (init == NULL_TREE)
7382     {
7383       if ((DECL_LANG_SPECIFIC (decl) == 0
7384            || DECL_IN_AGGR_P (decl) == 0)
7385           && ! DECL_THIS_EXTERN (decl))
7386         cp_error ("`%D' declared as reference but not initialized", decl);
7387       return NULL_TREE;
7388     }
7389
7390   if (init == error_mark_node)
7391     return NULL_TREE;
7392
7393   if (TREE_CODE (init) == CONSTRUCTOR)
7394     {
7395       cp_error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
7396       return NULL_TREE;
7397     }
7398
7399   if (TREE_CODE (init) == TREE_LIST)
7400     init = build_compound_expr (init);
7401
7402   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
7403     init = convert_from_reference (init);
7404
7405   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
7406       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
7407     {
7408       /* Note: default conversion is only called in very special cases.  */
7409       init = default_conversion (init);
7410     }
7411
7412   /* Convert INIT to the reference type TYPE.  This may involve the
7413      creation of a temporary, whose lifetime must be the same as that
7414      of the reference.  If so, a DECL_STMT for the temporary will be
7415      added just after the DECL_STMT for DECL.  That's why we don't set
7416      DECL_INITIAL for local references (instead assigning to them
7417      explicitly); we need to allow the temporary to be initialized
7418      first.  */
7419   tmp = convert_to_reference
7420     (type, init, CONV_IMPLICIT,
7421      LOOKUP_ONLYCONVERTING|LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND,
7422      decl);
7423
7424   if (tmp == error_mark_node)
7425     return NULL_TREE;
7426   else if (tmp == NULL_TREE)
7427     {
7428       cp_error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
7429       return NULL_TREE;
7430     }
7431
7432   init = tmp;
7433   tmp = save_expr (tmp);
7434   if (TREE_STATIC (decl) && !TREE_CONSTANT (tmp))
7435     return tmp;
7436
7437   if (building_stmt_tree ())
7438     {
7439       /* Initialize the declaration.  */
7440       tmp = build (INIT_EXPR, TREE_TYPE (decl), decl, tmp);
7441       finish_expr_stmt (tmp);
7442     }
7443   else
7444     DECL_INITIAL (decl) = tmp;
7445
7446   return NULL_TREE;
7447 }
7448
7449 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7450    mucking with forces it does not comprehend (i.e. initialization with a
7451    constructor).  If we are at global scope and won't go into COMMON, fill
7452    it in with a dummy CONSTRUCTOR to force the variable into .data;
7453    otherwise we can use error_mark_node.  */
7454
7455 static tree
7456 obscure_complex_init (decl, init)
7457      tree decl, init;
7458 {
7459   if (! flag_no_inline && TREE_STATIC (decl))
7460     {
7461       if (extract_init (decl, init))
7462         return NULL_TREE;
7463     }
7464
7465 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7466   if (toplevel_bindings_p () && ! DECL_COMMON (decl))
7467     DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
7468                                  NULL_TREE);
7469   else
7470 #endif
7471     DECL_INITIAL (decl) = error_mark_node;
7472
7473   return init;
7474 }
7475
7476 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7477    array until we finish parsing the initializer.  If that's the
7478    situation we're in, update DECL accordingly.  */
7479
7480 static void
7481 maybe_deduce_size_from_array_init (decl, init)
7482      tree decl;
7483      tree init;
7484 {
7485   tree type = TREE_TYPE (decl);
7486
7487   if (TREE_CODE (type) == ARRAY_TYPE
7488       && TYPE_DOMAIN (type) == NULL_TREE
7489       && TREE_CODE (decl) != TYPE_DECL)
7490     {
7491       /* do_default is really a C-ism to deal with tentative definitions.
7492          But let's leave it here to ease the eventual merge.  */
7493       int do_default = !DECL_EXTERNAL (decl);
7494       tree initializer = init ? init : DECL_INITIAL (decl);
7495       int failure = complete_array_type (type, initializer, do_default);
7496
7497       if (failure == 1)
7498         cp_error ("initializer fails to determine size of `%D'", decl);
7499
7500       if (failure == 2)
7501         {
7502           if (do_default)
7503             cp_error ("array size missing in `%D'", decl);
7504           /* If a `static' var's size isn't known, make it extern as
7505              well as static, so it does not get allocated.  If it's not
7506              `static', then don't mark it extern; finish_incomplete_decl
7507              will give it a default size and it will get allocated.  */
7508           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7509             DECL_EXTERNAL (decl) = 1;
7510         }
7511
7512       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7513           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7514                               integer_zero_node))
7515         cp_error ("zero-size array `%D'", decl);
7516
7517       layout_decl (decl, 0);
7518     }
7519 }
7520
7521 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7522    any appropriate error messages regarding the layout.  */
7523
7524 static void
7525 layout_var_decl (decl)
7526      tree decl;
7527 {
7528   tree type = TREE_TYPE (decl);
7529 #if 0
7530   tree ttype = target_type (type);
7531 #endif
7532
7533   /* If we haven't already layed out this declaration, do so now.
7534      Note that we must not call complete type for an external object
7535      because it's type might involve templates that we are not
7536      supposed to isntantiate yet.  (And it's perfectly legal to say
7537      `extern X x' for some incomplete type `X'.)  */
7538   if (!DECL_EXTERNAL (decl))
7539     complete_type (type);
7540   if (!DECL_SIZE (decl) && COMPLETE_TYPE_P (type))
7541     layout_decl (decl, 0);
7542
7543   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7544     {
7545       /* An automatic variable with an incomplete type: that is an error.
7546          Don't talk about array types here, since we took care of that
7547          message in grokdeclarator.  */
7548       cp_error ("storage size of `%D' isn't known", decl);
7549       TREE_TYPE (decl) = error_mark_node;
7550     }
7551 #if 0
7552   /* Keep this code around in case we later want to control debug info
7553      based on whether a type is "used".  (jason 1999-11-11) */
7554
7555   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7556     /* Let debugger know it should output info for this type.  */
7557     note_debug_info_needed (ttype);
7558
7559   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7560     note_debug_info_needed (DECL_CONTEXT (decl));
7561 #endif
7562
7563   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7564       && DECL_SIZE (decl) != NULL_TREE
7565       && ! TREE_CONSTANT (DECL_SIZE (decl)))
7566     {
7567       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7568         constant_expression_warning (DECL_SIZE (decl));
7569       else
7570         cp_error ("storage size of `%D' isn't constant", decl);
7571     }
7572
7573   if (TREE_STATIC (decl)
7574       && !DECL_ARTIFICIAL (decl)
7575       && current_function_decl
7576       && DECL_CONTEXT (decl) == current_function_decl)
7577     push_local_name (decl);
7578 }
7579
7580 /* If a local static variable is declared in an inline function, or if
7581    we have a weak definition, we must endeavor to create only one
7582    instance of the variable at link-time.  */
7583
7584 static void
7585 maybe_commonize_var (decl)
7586      tree decl;
7587 {
7588   /* Static data in a function with comdat linkage also has comdat
7589      linkage.  */
7590   if (TREE_STATIC (decl)
7591       /* Don't mess with __FUNCTION__.  */
7592       && ! DECL_ARTIFICIAL (decl)
7593       && current_function_decl
7594       && DECL_CONTEXT (decl) == current_function_decl
7595       && (DECL_DECLARED_INLINE_P (current_function_decl)
7596           || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7597       && TREE_PUBLIC (current_function_decl))
7598     {
7599       /* If flag_weak, we don't need to mess with this, as we can just
7600          make the function weak, and let it refer to its unique local
7601          copy.  This works because we don't allow the function to be
7602          inlined.  */
7603       if (! flag_weak)
7604         {
7605           if (DECL_INTERFACE_KNOWN (current_function_decl))
7606             {
7607               TREE_PUBLIC (decl) = 1;
7608               DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7609             }
7610           else if (DECL_INITIAL (decl) == NULL_TREE
7611                    || DECL_INITIAL (decl) == error_mark_node)
7612             {
7613               TREE_PUBLIC (decl) = 1;
7614               DECL_COMMON (decl) = 1;
7615             }
7616           /* else we lose. We can only do this if we can use common,
7617              which we can't if it has been initialized.  */
7618
7619           if (!TREE_PUBLIC (decl))
7620             {
7621               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7622               cp_warning_at ("  you can work around this by removing the initializer", decl);
7623             }
7624         }
7625       else
7626         comdat_linkage (decl);
7627     }
7628   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7629     /* Set it up again; we might have set DECL_INITIAL since the last
7630        time.  */
7631     comdat_linkage (decl);
7632 }
7633
7634 /* Issue an error message if DECL is an uninitialized const variable.  */
7635
7636 static void
7637 check_for_uninitialized_const_var (decl)
7638      tree decl;
7639 {
7640   tree type = TREE_TYPE (decl);
7641
7642   /* ``Unless explicitly declared extern, a const object does not have
7643      external linkage and must be initialized. ($8.4; $12.1)'' ARM
7644      7.1.6 */
7645   if (TREE_CODE (decl) == VAR_DECL
7646       && TREE_CODE (type) != REFERENCE_TYPE
7647       && CP_TYPE_CONST_P (type)
7648       && !TYPE_NEEDS_CONSTRUCTING (type)
7649       && !DECL_INITIAL (decl))
7650     cp_error ("uninitialized const `%D'", decl);
7651 }
7652
7653 /* Verify INIT (the initializer for DECL), and record the
7654    initialization in DECL_INITIAL, if appropriate.  Returns a new
7655    value for INIT.  */
7656
7657 static tree
7658 check_initializer (decl, init)
7659      tree decl;
7660      tree init;
7661 {
7662   tree type;
7663
7664   if (TREE_CODE (decl) == FIELD_DECL)
7665     return init;
7666
7667   type = TREE_TYPE (decl);
7668
7669   /* If `start_decl' didn't like having an initialization, ignore it now.  */
7670   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7671     init = NULL_TREE;
7672
7673   /* Check the initializer.  */
7674   if (init)
7675     {
7676       /* Things that are going to be initialized need to have complete
7677          type.  */
7678       TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7679
7680       if (type == error_mark_node)
7681         /* We will have already complained.  */
7682         init = NULL_TREE;
7683       else if (COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
7684         {
7685           cp_error ("variable-sized object `%D' may not be initialized", decl);
7686           init = NULL_TREE;
7687         }
7688       else if (TREE_CODE (type) == ARRAY_TYPE
7689                && !COMPLETE_TYPE_P (TREE_TYPE (type)))
7690         {
7691           cp_error ("elements of array `%#D' have incomplete type", decl);
7692           init = NULL_TREE;
7693         }
7694       else if (!COMPLETE_TYPE_P (type))
7695         {
7696           cp_error ("`%D' has incomplete type", decl);
7697           TREE_TYPE (decl) = error_mark_node;
7698           init = NULL_TREE;
7699         }
7700     }
7701
7702   if (TREE_CODE (decl) == CONST_DECL)
7703     {
7704       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7705
7706       DECL_INITIAL (decl) = init;
7707
7708       my_friendly_assert (init != NULL_TREE, 149);
7709       init = NULL_TREE;
7710     }
7711   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7712     {
7713       init = grok_reference_init (decl, type, init);
7714       if (init)
7715         init = obscure_complex_init (decl, init);
7716     }
7717   else if (init)
7718     {
7719       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7720         {
7721           if (TREE_CODE (type) == ARRAY_TYPE)
7722             init = digest_init (type, init, (tree *) 0);
7723           else if (TREE_CODE (init) == CONSTRUCTOR
7724                    && TREE_HAS_CONSTRUCTOR (init))
7725             {
7726               if (TYPE_NON_AGGREGATE_CLASS (type))
7727                 {
7728                   cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7729                             decl);
7730                   init = error_mark_node;
7731                 }
7732               else
7733                 goto dont_use_constructor;
7734             }
7735         }
7736       else
7737         {
7738         dont_use_constructor:
7739           if (TREE_CODE (init) != TREE_VEC)
7740             init = store_init_value (decl, init);
7741         }
7742
7743       if (init)
7744         /* We must hide the initializer so that expand_decl
7745            won't try to do something it does not understand.  */
7746         init = obscure_complex_init (decl, init);
7747     }
7748   else if (DECL_EXTERNAL (decl))
7749     ;
7750   else if (TYPE_P (type)
7751            && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
7752     {
7753       tree core_type = strip_array_types (type);
7754
7755       if (! TYPE_NEEDS_CONSTRUCTING (core_type))
7756         {
7757           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
7758             cp_error ("structure `%D' with uninitialized const members", decl);
7759           if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
7760             cp_error ("structure `%D' with uninitialized reference members",
7761                       decl);
7762         }
7763
7764       check_for_uninitialized_const_var (decl);
7765
7766       if (COMPLETE_TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
7767         init = obscure_complex_init (decl, NULL_TREE);
7768
7769     }
7770   else
7771     check_for_uninitialized_const_var (decl);
7772
7773   return init;
7774 }
7775
7776 /* If DECL is not a local variable, give it RTL.  */
7777
7778 static void
7779 make_rtl_for_nonlocal_decl (decl, init, asmspec)
7780      tree decl;
7781      tree init;
7782      const char *asmspec;
7783 {
7784   int toplev = toplevel_bindings_p ();
7785   int defer_p;
7786
7787   /* Handle non-variables up front.  */
7788   if (TREE_CODE (decl) != VAR_DECL)
7789     {
7790       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7791       return;
7792     }
7793
7794   /* If we see a class member here, it should be a static data
7795      member.  */
7796   if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
7797     {
7798       my_friendly_assert (TREE_STATIC (decl), 19990828);
7799       /* An in-class declaration of a static data member should be
7800          external; it is only a declaration, and not a definition.  */
7801       if (init == NULL_TREE)
7802         my_friendly_assert (DECL_EXTERNAL (decl), 20000723);
7803     }
7804
7805   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
7806   if (asmspec)
7807     {
7808       SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
7809       /* The `register' keyword, when used together with an
7810          asm-specification, indicates that the variable should be
7811          placed in a particular register.  */
7812       if (DECL_REGISTER (decl))
7813         DECL_C_HARD_REGISTER (decl) = 1;
7814     }
7815
7816   /* We don't create any RTL for local variables.  */
7817   if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
7818     return;
7819
7820   /* We defer emission of local statics until the corresponding
7821      DECL_STMT is expanded.  */
7822   defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
7823
7824   /* We try to defer namespace-scope static constants so that they are
7825      not emitted into the object file unncessarily.  */
7826   if (!DECL_VIRTUAL_P (decl)
7827       && TREE_READONLY (decl)
7828       && DECL_INITIAL (decl) != NULL_TREE
7829       && DECL_INITIAL (decl) != error_mark_node
7830       && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
7831       && toplev
7832       && !TREE_PUBLIC (decl))
7833     {
7834       /* Fool with the linkage according to #pragma interface.  */
7835       if (!interface_unknown)
7836         {
7837           TREE_PUBLIC (decl) = 1;
7838           DECL_EXTERNAL (decl) = interface_only;
7839         }
7840
7841       defer_p = 1;
7842     }
7843
7844   /* If we're deferring the variable, we only need to make RTL if
7845      there's an ASMSPEC.  Otherwise, we'll lazily create it later when
7846      we need it.  (There's no way to lazily create RTL for things that
7847      have assembly specs because the information about the specifier
7848      isn't stored in the tree, yet)  */
7849   if (defer_p && asmspec)
7850     make_decl_rtl (decl, asmspec);
7851   /* If we're not deferring, go ahead and assemble the variable.  */
7852   else if (!defer_p)
7853     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7854 }
7855
7856 /* The old ARM scoping rules injected variables declared in the
7857    initialization statement of a for-statement into the surrounding
7858    scope.  We support this usage, in order to be backward-compatible.
7859    DECL is a just-declared VAR_DECL; if necessary inject its
7860    declaration into the surrounding scope.  */
7861
7862 void
7863 maybe_inject_for_scope_var (decl)
7864      tree decl;
7865 {
7866   if (!DECL_NAME (decl))
7867     return;
7868
7869   if (current_binding_level->is_for_scope)
7870     {
7871       struct binding_level *outer
7872         = current_binding_level->level_chain;
7873
7874       /* Check to see if the same name is already bound at the outer
7875          level, either because it was directly declared, or because a
7876          dead for-decl got preserved.  In either case, the code would
7877          not have been valid under the ARM scope rules, so clear
7878          is_for_scope for the current_binding_level.
7879
7880          Otherwise, we need to preserve the temp slot for decl to last
7881          into the outer binding level.  */
7882
7883       tree outer_binding
7884         = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
7885
7886       if (outer_binding && BINDING_LEVEL (outer_binding) == outer
7887           && (TREE_CODE (BINDING_VALUE (outer_binding))
7888               == VAR_DECL)
7889           && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
7890         {
7891           BINDING_VALUE (outer_binding)
7892             = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
7893           current_binding_level->is_for_scope = 0;
7894         }
7895       else if (DECL_IN_MEMORY_P (decl))
7896         preserve_temp_slots (DECL_RTL (decl));
7897     }
7898 }
7899
7900 /* Generate code to initialize DECL (a local variable).  */
7901
7902 void
7903 initialize_local_var (decl, init, flags)
7904      tree decl;
7905      tree init;
7906      int flags;
7907 {
7908   tree type = TREE_TYPE (decl);
7909
7910   /* If the type is bogus, don't bother initializing the variable.  */
7911   if (type == error_mark_node)
7912     return;
7913
7914   if (DECL_SIZE (decl) == NULL_TREE && !TREE_STATIC (decl))
7915     {
7916       /* If we used it already as memory, it must stay in memory.  */
7917       DECL_INITIAL (decl) = NULL_TREE;
7918       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
7919     }
7920
7921   /* Local statics are handled differently from ordinary automatic
7922      variables.  */
7923   if (TREE_STATIC (decl))
7924     {
7925       if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7926           || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7927         expand_static_init (decl, init);
7928       return;
7929     }
7930
7931   if (DECL_SIZE (decl) && type != error_mark_node)
7932     {
7933       int already_used;
7934
7935       /* Compute and store the initial value.  */
7936       already_used = TREE_USED (decl) || TREE_USED (type);
7937
7938       if (init || TYPE_NEEDS_CONSTRUCTING (type))
7939         {
7940           int saved_stmts_are_full_exprs_p;
7941
7942           my_friendly_assert (building_stmt_tree (), 20000906);
7943           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
7944           current_stmt_tree ()->stmts_are_full_exprs_p = 1;
7945           finish_expr_stmt (build_aggr_init (decl, init, flags));
7946           current_stmt_tree ()->stmts_are_full_exprs_p =
7947             saved_stmts_are_full_exprs_p;
7948         }
7949
7950       /* Set this to 0 so we can tell whether an aggregate which was
7951          initialized was ever used.  Don't do this if it has a
7952          destructor, so we don't complain about the 'resource
7953          allocation is initialization' idiom.  Now set
7954          attribute((unused)) on types so decls of that type will be
7955          marked used. (see TREE_USED, above.)  */
7956       if (TYPE_NEEDS_CONSTRUCTING (type)
7957           && ! already_used
7958           && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
7959           && DECL_NAME (decl))
7960         TREE_USED (decl) = 0;
7961       else if (already_used)
7962         TREE_USED (decl) = 1;
7963     }
7964 }
7965
7966 /* Generate code to destroy DECL (a local variable).  */
7967
7968 static void
7969 destroy_local_var (decl)
7970      tree decl;
7971 {
7972   tree type = TREE_TYPE (decl);
7973   tree cleanup;
7974
7975   /* Only variables get cleaned up.  */
7976   if (TREE_CODE (decl) != VAR_DECL)
7977     return;
7978
7979   /* And only things with destructors need cleaning up.  */
7980   if (type == error_mark_node
7981       || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
7982     return;
7983
7984   if (TREE_CODE (decl) == VAR_DECL &&
7985       (DECL_EXTERNAL (decl) || TREE_STATIC (decl)))
7986     /* We don't clean up things that aren't defined in this
7987        translation unit, or that need a static cleanup.  The latter
7988        are handled by finish_file.  */
7989     return;
7990
7991   /* Compute the cleanup.  */
7992   cleanup = maybe_build_cleanup (decl);
7993
7994   /* Record the cleanup required for this declaration.  */
7995   if (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node
7996       && cleanup)
7997     finish_decl_cleanup (decl, cleanup);
7998 }
7999
8000 /* Finish processing of a declaration;
8001    install its line number and initial value.
8002    If the length of an array type is not known before,
8003    it must be determined now, from the initial value, or it is an error.
8004
8005    INIT holds the value of an initializer that should be allowed to escape
8006    the normal rules.
8007
8008    FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
8009    if the (init) syntax was used.  */
8010
8011 void
8012 cp_finish_decl (decl, init, asmspec_tree, flags)
8013      tree decl, init;
8014      tree asmspec_tree;
8015      int flags;
8016 {
8017   register tree type;
8018   tree ttype = NULL_TREE;
8019   const char *asmspec = NULL;
8020   int was_readonly = 0;
8021
8022   if (! decl)
8023     {
8024       if (init)
8025         error ("assignment (not initialization) in declaration");
8026       return;
8027     }
8028
8029   /* If a name was specified, get the string.  */
8030   if (asmspec_tree)
8031       asmspec = TREE_STRING_POINTER (asmspec_tree);
8032
8033   if (init && TREE_CODE (init) == NAMESPACE_DECL)
8034     {
8035       cp_error ("cannot initialize `%D' to namespace `%D'",
8036                 decl, init);
8037       init = NULL_TREE;
8038     }
8039
8040   if (current_class_type
8041       && CP_DECL_CONTEXT (decl) == current_class_type
8042       && TYPE_BEING_DEFINED (current_class_type)
8043       && (DECL_INITIAL (decl) || init))
8044     DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
8045
8046   if (TREE_CODE (decl) == VAR_DECL
8047       && DECL_CONTEXT (decl)
8048       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
8049       && DECL_CONTEXT (decl) != current_namespace
8050       && init)
8051     {
8052       /* Leave the namespace of the object. */
8053       pop_decl_namespace ();
8054     }
8055
8056   type = TREE_TYPE (decl);
8057
8058   if (type == error_mark_node)
8059     return;
8060
8061   /* Add this declaration to the statement-tree.  */
8062   if (building_stmt_tree ()
8063       && at_function_scope_p ()
8064       && TREE_CODE (decl) != RESULT_DECL)
8065     add_decl_stmt (decl);
8066
8067   if (TYPE_HAS_MUTABLE_P (type))
8068     TREE_READONLY (decl) = 0;
8069
8070   if (processing_template_decl)
8071     {
8072       if (init && DECL_INITIAL (decl))
8073         DECL_INITIAL (decl) = init;
8074       goto finish_end0;
8075     }
8076
8077   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
8078   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
8079
8080   /* Take care of TYPE_DECLs up front.  */
8081   if (TREE_CODE (decl) == TYPE_DECL)
8082     {
8083       if (init && DECL_INITIAL (decl))
8084         {
8085           /* typedef foo = bar; store the type of bar as the type of foo.  */
8086           TREE_TYPE (decl) = type = TREE_TYPE (init);
8087           DECL_INITIAL (decl) = init = NULL_TREE;
8088         }
8089       if (type != error_mark_node
8090           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
8091         {
8092           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
8093             cp_warning ("shadowing previous type declaration of `%#D'", decl);
8094           set_identifier_type_value (DECL_NAME (decl), type);
8095           CLASSTYPE_GOT_SEMICOLON (type) = 1;
8096         }
8097       GNU_xref_decl (current_function_decl, decl);
8098
8099       /* If we have installed this as the canonical typedef for this
8100          type, and that type has not been defined yet, delay emitting
8101          the debug information for it, as we will emit it later.  */
8102       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
8103           && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
8104         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
8105
8106       rest_of_decl_compilation (decl, NULL_PTR,
8107                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
8108       goto finish_end;
8109     }
8110
8111   if (TREE_CODE (decl) != FUNCTION_DECL)
8112     ttype = target_type (type);
8113
8114   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
8115       && TYPE_NEEDS_CONSTRUCTING (type))
8116     {
8117       /* Currently, GNU C++ puts constants in text space, making them
8118          impossible to initialize.  In the future, one would hope for
8119          an operating system which understood the difference between
8120          initialization and the running of a program.  */
8121       was_readonly = 1;
8122       TREE_READONLY (decl) = 0;
8123     }
8124
8125   if (TREE_CODE (decl) == FIELD_DECL && asmspec)
8126     {
8127       /* This must override the asm specifier which was placed by
8128          grokclassfn.  Lay this out fresh.  */
8129       SET_DECL_RTL (TREE_TYPE (decl), NULL_RTX);
8130       SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
8131       make_decl_rtl (decl, asmspec);
8132     }
8133
8134   /* Deduce size of array from initialization, if not already known.  */
8135   maybe_deduce_size_from_array_init (decl, init);
8136   init = check_initializer (decl, init);
8137
8138   GNU_xref_decl (current_function_decl, decl);
8139
8140   if (TREE_CODE (decl) == VAR_DECL)
8141     layout_var_decl (decl);
8142
8143   /* Output the assembler code and/or RTL code for variables and functions,
8144      unless the type is an undefined structure or union.
8145      If not, it will get done when the type is completed.  */
8146   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
8147       || TREE_CODE (decl) == RESULT_DECL)
8148     {
8149       if (TREE_CODE (decl) == VAR_DECL)
8150         maybe_commonize_var (decl);
8151
8152       make_rtl_for_nonlocal_decl (decl, init, asmspec);
8153
8154       if (TREE_CODE (type) == FUNCTION_TYPE
8155           || TREE_CODE (type) == METHOD_TYPE)
8156         abstract_virtuals_error (decl,
8157                                  strip_array_types (TREE_TYPE (type)));
8158       else
8159         abstract_virtuals_error (decl, strip_array_types (type));
8160
8161       if (TREE_CODE (decl) == FUNCTION_DECL)
8162         ;
8163       else if (DECL_EXTERNAL (decl)
8164                && ! (DECL_LANG_SPECIFIC (decl)
8165                      && DECL_NOT_REALLY_EXTERN (decl)))
8166         {
8167           if (init)
8168             DECL_INITIAL (decl) = init;
8169         }
8170       else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
8171         {
8172           /* This is a local declaration.  */
8173           if (doing_semantic_analysis_p ())
8174             maybe_inject_for_scope_var (decl);
8175           /* Initialize the local variable.  But, if we're building a
8176              statement-tree, we'll do the initialization when we
8177              expand the tree.  */
8178           if (processing_template_decl)
8179             {
8180               if (init || DECL_INITIAL (decl) == error_mark_node)
8181                 DECL_INITIAL (decl) = init;
8182             }
8183           else
8184             {
8185               /* If we're not building RTL, then we need to do so
8186                  now.  */
8187               my_friendly_assert (building_stmt_tree (), 20000906);
8188               /* Initialize the variable.  */
8189               initialize_local_var (decl, init, flags);
8190               /* Clean up the variable.  */
8191               destroy_local_var (decl);
8192             }
8193         }
8194       else if (TREE_STATIC (decl) && type != error_mark_node)
8195         {
8196           /* Cleanups for static variables are handled by `finish_file'.  */
8197           if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
8198               || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8199             expand_static_init (decl, init);
8200         }
8201     finish_end0:
8202
8203       /* Undo call to `pushclass' that was done in `start_decl'
8204          due to initialization of qualified member variable.
8205          I.e., Foo::x = 10;  */
8206       {
8207         tree context = CP_DECL_CONTEXT (decl);
8208         if (context
8209             && TYPE_P (context)
8210             && (TREE_CODE (decl) == VAR_DECL
8211                 /* We also have a pushclass done that we need to undo here
8212                    if we're at top level and declare a method.  */
8213                 || TREE_CODE (decl) == FUNCTION_DECL)
8214             /* If size hasn't been set, we're still defining it,
8215                and therefore inside the class body; don't pop
8216                the binding level..  */
8217             && COMPLETE_TYPE_P (context)
8218             && context == current_class_type)
8219           pop_nested_class ();
8220       }
8221     }
8222
8223  finish_end:
8224
8225   if (was_readonly)
8226     TREE_READONLY (decl) = 1;
8227 }
8228
8229 /* This is here for a midend callback from c-common.c */
8230
8231 void
8232 finish_decl (decl, init, asmspec_tree)
8233      tree decl, init;
8234      tree asmspec_tree;
8235 {
8236   cp_finish_decl (decl, init, asmspec_tree, 0);
8237 }
8238
8239 /* Returns a declaration for a VAR_DECL as if:
8240
8241      extern "C" TYPE NAME;
8242
8243    had been seen.  Used to create compiler-generated global
8244    variables.  */
8245
8246 tree
8247 declare_global_var (name, type)
8248      tree name;
8249      tree type;
8250 {
8251   tree decl;
8252
8253   push_to_top_level ();
8254   decl = build_decl (VAR_DECL, name, type);
8255   TREE_PUBLIC (decl) = 1;
8256   DECL_EXTERNAL (decl) = 1;
8257   DECL_ARTIFICIAL (decl) = 1;
8258   pushdecl (decl);
8259   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
8260   pop_from_top_level ();
8261
8262   return decl;
8263 }
8264
8265 /* Returns a pointer to the `atexit' function.  Note that if
8266    FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
8267    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
8268
8269 static tree
8270 get_atexit_node ()
8271 {
8272   tree atexit_fndecl;
8273   tree arg_types;
8274   tree fn_type;
8275   tree fn_ptr_type;
8276   const char *name;
8277
8278   if (atexit_node)
8279     return atexit_node;
8280
8281   if (flag_use_cxa_atexit)
8282     {
8283       /* The declaration for `__cxa_atexit' is:
8284
8285            int __cxa_atexit (void (*)(void *), void *, void *)
8286
8287          We build up the argument types and then then function type
8288          itself.  */
8289
8290       /* First, build the pointer-to-function type for the first
8291          argument.  */
8292       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8293       fn_type = build_function_type (void_type_node, arg_types);
8294       fn_ptr_type = build_pointer_type (fn_type);
8295       /* Then, build the rest of the argument types.  */
8296       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8297       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
8298       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
8299       /* And the final __cxa_atexit type.  */
8300       fn_type = build_function_type (integer_type_node, arg_types);
8301       fn_ptr_type = build_pointer_type (fn_type);
8302       name = "__cxa_atexit";
8303     }
8304   else
8305     {
8306       /* The declaration for `atexit' is:
8307
8308            int atexit (void (*)());
8309
8310          We build up the argument types and then then function type
8311          itself.  */
8312       fn_type = build_function_type (void_type_node, void_list_node);
8313       fn_ptr_type = build_pointer_type (fn_type);
8314       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
8315       /* Build the final atexit type.  */
8316       fn_type = build_function_type (integer_type_node, arg_types);
8317       name = "atexit";
8318     }
8319
8320   /* Now, build the function declaration.  */
8321   push_lang_context (lang_name_c);
8322   atexit_fndecl = build_library_fn_ptr (name, fn_type);
8323   mark_used (atexit_fndecl);
8324   pop_lang_context ();
8325   atexit_node = default_conversion (atexit_fndecl);
8326
8327   return atexit_node;
8328 }
8329
8330 /* Returns the __dso_handle VAR_DECL.  */
8331
8332 static tree
8333 get_dso_handle_node ()
8334 {
8335   if (dso_handle_node)
8336     return dso_handle_node;
8337
8338   /* Declare the variable.  */
8339   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8340                                         ptr_type_node);
8341
8342   return dso_handle_node;
8343 }
8344
8345 /* Begin a new function with internal linkage whose job will be simply
8346    to destroy some particular variable.  */
8347
8348 static tree
8349 start_cleanup_fn ()
8350 {
8351   static int counter = 0;
8352   int old_interface_unknown = interface_unknown;
8353   char name[32];
8354   tree parmtypes;
8355   tree fntype;
8356   tree fndecl;
8357
8358   push_to_top_level ();
8359
8360   /* No need to mangle this.  */
8361   push_lang_context (lang_name_c);
8362
8363   interface_unknown = 1;
8364
8365   /* Build the parameter-types.  */
8366   parmtypes = void_list_node;
8367   /* Functions passed to __cxa_atexit take an additional parameter.
8368      We'll just ignore it.  After we implement the new calling
8369      convention for destructors, we can eliminate the use of
8370      additional cleanup functions entirely in the -fnew-abi case.  */
8371   if (flag_use_cxa_atexit)
8372     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8373   /* Build the function type itself.  */
8374   fntype = build_function_type (void_type_node, parmtypes);
8375   /* Build the name of the function.  */
8376   sprintf (name, "__tcf_%d", counter++);
8377   /* Build the function declaration.  */
8378   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8379   /* It's a function with internal linkage, generated by the
8380      compiler.  */
8381   TREE_PUBLIC (fndecl) = 0;
8382   DECL_ARTIFICIAL (fndecl) = 1;
8383   /* Make the function `inline' so that it is only emitted if it is
8384      actually needed.  It is unlikely that it will be inlined, since
8385      it is only called via a function pointer, but we avoid unncessary
8386      emissions this way.  */
8387   DECL_INLINE (fndecl) = 1;
8388   /* Build the parameter.  */
8389   if (flag_use_cxa_atexit)
8390     {
8391       tree parmdecl;
8392
8393       parmdecl = build_decl (PARM_DECL, NULL_TREE, ptr_type_node);
8394       DECL_CONTEXT (parmdecl) = fndecl;
8395       DECL_ARG_TYPE (parmdecl) = ptr_type_node;
8396       TREE_USED (parmdecl) = 1;
8397       DECL_ARGUMENTS (fndecl) = parmdecl;
8398     }
8399
8400   pushdecl (fndecl);
8401   start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8402   do_pushlevel ();
8403
8404   interface_unknown = old_interface_unknown;
8405
8406   pop_lang_context ();
8407
8408   return current_function_decl;
8409 }
8410
8411 /* Finish the cleanup function begun by start_cleanup_fn.  */
8412
8413 static void
8414 end_cleanup_fn ()
8415 {
8416   do_poplevel ();
8417
8418   expand_body (finish_function (0));
8419
8420   pop_from_top_level ();
8421 }
8422
8423 /* Generate code to handle the destruction of DECL, an object with
8424    static storage duration.  */
8425
8426 void
8427 register_dtor_fn (decl)
8428      tree decl;
8429 {
8430   tree cleanup;
8431   tree compound_stmt;
8432   tree args;
8433   tree fcall;
8434
8435   int saved_flag_access_control;
8436
8437   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8438     return;
8439
8440   /* Call build_cleanup before we enter the anonymous function so that
8441      any access checks will be done relative to the current scope,
8442      rather than the scope of the anonymous function.  */
8443   build_cleanup (decl);
8444
8445   /* Now start the function.  */
8446   cleanup = start_cleanup_fn ();
8447
8448   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
8449      to the original function, rather than the anonymous one.  That
8450      will make the back-end think that nested functions are in use,
8451      which causes confusion.  */
8452   saved_flag_access_control = flag_access_control;
8453   flag_access_control = 0;
8454   fcall = build_cleanup (decl);
8455   flag_access_control = saved_flag_access_control;
8456
8457   /* Create the body of the anonymous function.  */
8458   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8459   finish_expr_stmt (fcall);
8460   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8461   end_cleanup_fn ();
8462
8463   /* Call atexit with the cleanup function.  */
8464   mark_addressable (cleanup);
8465   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8466   if (flag_use_cxa_atexit)
8467     {
8468       args = tree_cons (NULL_TREE, get_dso_handle_node (), NULL_TREE);
8469       args = tree_cons (NULL_TREE, null_pointer_node, args);
8470       args = tree_cons (NULL_TREE, cleanup, args);
8471     }
8472   else
8473     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8474   finish_expr_stmt (build_function_call (get_atexit_node (), args));
8475 }
8476
8477 void
8478 expand_static_init (decl, init)
8479      tree decl;
8480      tree init;
8481 {
8482   tree oldstatic = value_member (decl, static_aggregates);
8483
8484   if (oldstatic)
8485     {
8486       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8487         cp_error ("multiple initializations given for `%D'", decl);
8488     }
8489   else if (! toplevel_bindings_p ())
8490     {
8491       /* Emit code to perform this initialization but once.  */
8492       tree if_stmt;
8493       tree then_clause;
8494       tree assignment;
8495       tree guard;
8496       tree guard_init;
8497
8498       /* Emit code to perform this initialization but once.  This code
8499          looks like:
8500
8501            static int guard = 0;
8502            if (!guard) {
8503              // Do initialization.
8504              guard = 1;
8505              // Register variable for destruction at end of program.
8506            }
8507
8508          Note that the `temp' variable is only set to 1 *after* the
8509          initialization is complete.  This ensures that an exception,
8510          thrown during the construction, will cause the variable to
8511          reinitialized when we pass through this code again, as per:
8512
8513            [stmt.dcl]
8514
8515            If the initialization exits by throwing an exception, the
8516            initialization is not complete, so it will be tried again
8517            the next time control enters the declaration.
8518
8519          In theory, this process should be thread-safe, too; multiple
8520          threads should not be able to initialize the variable more
8521          than once.  We don't yet attempt to ensure thread-safety.  */
8522
8523       /* Create the guard variable.  */
8524       guard = get_guard (decl);
8525
8526       /* Begin the conditional initialization.  */
8527       if_stmt = begin_if_stmt ();
8528       finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
8529       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8530
8531       /* Do the initialization itself.  */
8532       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8533           || (init && TREE_CODE (init) == TREE_LIST))
8534         assignment = build_aggr_init (decl, init, 0);
8535       else if (init)
8536         /* The initialization we're doing here is just a bitwise
8537            copy.  */
8538         assignment = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
8539       else
8540         assignment = NULL_TREE;
8541
8542       /* Once the assignment is complete, set TEMP to 1.  Since the
8543          construction of the static object is complete at this point,
8544          we want to make sure TEMP is set to 1 even if a temporary
8545          constructed during the initialization throws an exception
8546          when it is destroyed.  So, we combine the initialization and
8547          the assignment to TEMP into a single expression, ensuring
8548          that when we call finish_expr_stmt the cleanups will not be
8549          run until after TEMP is set to 1.  */
8550       guard_init = set_guard (guard);
8551       if (assignment)
8552         {
8553           assignment = tree_cons (NULL_TREE, assignment,
8554                                   build_tree_list (NULL_TREE,
8555                                                    guard_init));
8556           assignment = build_compound_expr (assignment);
8557         }
8558       else
8559         assignment = guard_init;
8560       finish_expr_stmt (assignment);
8561
8562       /* Use atexit to register a function for destroying this static
8563          variable.  */
8564       register_dtor_fn (decl);
8565
8566       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8567       finish_then_clause (if_stmt);
8568       finish_if_stmt ();
8569     }
8570   else
8571     static_aggregates = tree_cons (init, decl, static_aggregates);
8572 }
8573
8574 /* Finish the declaration of a catch-parameter.  */
8575
8576 tree
8577 start_handler_parms (declspecs, declarator)
8578      tree declspecs;
8579      tree declarator;
8580 {
8581   tree decl;
8582   if (declspecs)
8583     {
8584       decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8585                              1, NULL_TREE);
8586       if (decl == NULL_TREE)
8587         error ("invalid catch parameter");
8588     }
8589   else
8590     decl = NULL_TREE;
8591
8592   return decl;
8593 }
8594
8595 \f
8596 /* Make TYPE a complete type based on INITIAL_VALUE.
8597    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8598    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
8599
8600 int
8601 complete_array_type (type, initial_value, do_default)
8602      tree type, initial_value;
8603      int do_default;
8604 {
8605   register tree maxindex = NULL_TREE;
8606   int value = 0;
8607
8608   if (initial_value)
8609     {
8610       /* An array of character type can be initialized from a
8611          brace-enclosed string constant.  */
8612       if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))
8613           && TREE_CODE (initial_value) == CONSTRUCTOR
8614           && CONSTRUCTOR_ELTS (initial_value)
8615           && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value)))
8616               == STRING_CST)
8617           && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value)) == NULL_TREE)
8618         initial_value = TREE_VALUE (CONSTRUCTOR_ELTS (initial_value));
8619
8620       /* Note MAXINDEX is really the maximum index, one less than the
8621          size.  */
8622       if (TREE_CODE (initial_value) == STRING_CST)
8623         {
8624           int eltsize
8625             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8626           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8627                                    / eltsize) - 1, 0);
8628         }
8629       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8630         {
8631           tree elts = CONSTRUCTOR_ELTS (initial_value);
8632
8633           maxindex = ssize_int (-1);
8634           for (; elts; elts = TREE_CHAIN (elts))
8635             {
8636               if (TREE_PURPOSE (elts))
8637                 maxindex = TREE_PURPOSE (elts);
8638               else
8639                 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
8640             }
8641           maxindex = copy_node (maxindex);
8642         }
8643       else
8644         {
8645           /* Make an error message unless that happened already.  */
8646           if (initial_value != error_mark_node)
8647             value = 1;
8648           else
8649             initial_value = NULL_TREE;
8650
8651           /* Prevent further error messages.  */
8652           maxindex = build_int_2 (0, 0);
8653         }
8654     }
8655
8656   if (!maxindex)
8657     {
8658       if (do_default)
8659         maxindex = build_int_2 (0, 0);
8660       value = 2;
8661     }
8662
8663   if (maxindex)
8664     {
8665       tree itype;
8666       tree domain;
8667
8668       domain = build_index_type (maxindex);
8669       TYPE_DOMAIN (type) = domain;
8670
8671       if (! TREE_TYPE (maxindex))
8672         TREE_TYPE (maxindex) = domain;
8673       if (initial_value)
8674         itype = TREE_TYPE (initial_value);
8675       else
8676         itype = NULL;
8677       if (itype && !TYPE_DOMAIN (itype))
8678         TYPE_DOMAIN (itype) = domain;
8679       /* The type of the main variant should never be used for arrays
8680          of different sizes.  It should only ever be completed with the
8681          size of the array.  */
8682       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8683         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8684     }
8685
8686   /* Lay out the type now that we can get the real answer.  */
8687
8688   layout_type (type);
8689
8690   return value;
8691 }
8692 \f
8693 /* Return zero if something is declared to be a member of type
8694    CTYPE when in the context of CUR_TYPE.  STRING is the error
8695    message to print in that case.  Otherwise, quietly return 1.  */
8696
8697 static int
8698 member_function_or_else (ctype, cur_type, flags)
8699      tree ctype, cur_type;
8700      enum overload_flags flags;
8701 {
8702   if (ctype && ctype != cur_type)
8703     {
8704       if (flags == DTOR_FLAG)
8705         cp_error ("destructor for alien class `%T' cannot be a member",
8706                   ctype);
8707       else
8708         cp_error ("constructor for alien class `%T' cannot be a member",
8709                   ctype);
8710       return 0;
8711     }
8712   return 1;
8713 }
8714 \f
8715 /* Subroutine of `grokdeclarator'.  */
8716
8717 /* Generate errors possibly applicable for a given set of specifiers.
8718    This is for ARM $7.1.2.  */
8719
8720 static void
8721 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8722      tree object;
8723      const char *type;
8724      int virtualp, quals, friendp, raises, inlinep;
8725 {
8726   if (virtualp)
8727     cp_error ("`%D' declared as a `virtual' %s", object, type);
8728   if (inlinep)
8729     cp_error ("`%D' declared as an `inline' %s", object, type);
8730   if (quals)
8731     cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8732               object, type);
8733   if (friendp)
8734     cp_error_at ("`%D' declared as a friend", object);
8735   if (raises && !TYPE_PTRFN_P (TREE_TYPE (object))
8736       && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))
8737     cp_error_at ("`%D' declared with an exception specification", object);
8738 }
8739
8740 /* CTYPE is class type, or null if non-class.
8741    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8742    or METHOD_TYPE.
8743    DECLARATOR is the function's name.
8744    VIRTUALP is truthvalue of whether the function is virtual or not.
8745    FLAGS are to be passed through to `grokclassfn'.
8746    QUALS are qualifiers indicating whether the function is `const'
8747    or `volatile'.
8748    RAISES is a list of exceptions that this function can raise.
8749    CHECK is 1 if we must find this method in CTYPE, 0 if we should
8750    not look, and -1 if we should not call `grokclassfn' at all.
8751
8752    Returns `NULL_TREE' if something goes wrong, after issuing
8753    applicable error messages.  */
8754
8755 static tree
8756 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8757             raises, check, friendp, publicp, inlinep, funcdef_flag,
8758             template_count, in_namespace)
8759      tree ctype, type;
8760      tree declarator;
8761      tree orig_declarator;
8762      int virtualp;
8763      enum overload_flags flags;
8764      tree quals, raises;
8765      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8766      tree in_namespace;
8767 {
8768   tree decl;
8769   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8770   int has_default_arg = 0;
8771   tree t;
8772
8773   if (raises)
8774     {
8775       type = build_exception_variant (type, raises);
8776     }
8777
8778   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8779   /* Propagate volatile out from type to decl. */
8780   if (TYPE_VOLATILE (type))
8781     TREE_THIS_VOLATILE (decl) = 1;
8782
8783   /* If this decl has namespace scope, set that up.  */
8784   if (in_namespace)
8785     set_decl_namespace (decl, in_namespace, friendp);
8786   else if (!ctype)
8787     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8788
8789   /* `main' and builtins have implicit 'C' linkage.  */
8790   if ((MAIN_NAME_P (declarator)
8791        || (IDENTIFIER_LENGTH (declarator) > 10
8792            && IDENTIFIER_POINTER (declarator)[0] == '_'
8793            && IDENTIFIER_POINTER (declarator)[1] == '_'
8794            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8795       && current_lang_name == lang_name_cplusplus
8796       && ctype == NULL_TREE
8797       /* NULL_TREE means global namespace.  */
8798       && DECL_CONTEXT (decl) == NULL_TREE)
8799     SET_DECL_LANGUAGE (decl, lang_c);
8800
8801   /* Should probably propagate const out from type to decl I bet (mrs).  */
8802   if (staticp)
8803     {
8804       DECL_STATIC_FUNCTION_P (decl) = 1;
8805       DECL_CONTEXT (decl) = ctype;
8806     }
8807
8808   if (ctype)
8809     DECL_CONTEXT (decl) = ctype;
8810
8811   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8812     {
8813       if (processing_template_decl)
8814         error ("cannot declare `::main' to be a template");
8815       if (inlinep)
8816         error ("cannot declare `::main' to be inline");
8817       if (!publicp)
8818         error ("cannot declare `::main' to be static");
8819       if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
8820                         integer_type_node))
8821         error ("`main' must return `int'");
8822       inlinep = 0;
8823       publicp = 1;
8824     }
8825
8826   /* Members of anonymous types and local classes have no linkage; make
8827      them internal.  */
8828   /* FIXME what if it gets a name from typedef?  */
8829   if (ctype && (TYPE_ANONYMOUS_P (ctype)
8830                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
8831     publicp = 0;
8832
8833   if (publicp)
8834     {
8835       /* [basic.link]: A name with no linkage (notably, the name of a class
8836          or enumeration declared in a local scope) shall not be used to
8837          declare an entity with linkage.
8838
8839          Only check this for public decls for now.  */
8840       t = no_linkage_check (TREE_TYPE (decl));
8841       if (t)
8842         {
8843           if (TYPE_ANONYMOUS_P (t))
8844             {
8845               if (DECL_EXTERN_C_P (decl))
8846                 /* Allow this; it's pretty common in C.  */;
8847               else
8848                 {
8849                   cp_pedwarn ("non-local function `%#D' uses anonymous type",
8850                               decl);
8851                   if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
8852                     cp_pedwarn_at ("\
8853 `%#D' does not refer to the unqualified type, so it is not used for linkage",
8854                                 TYPE_NAME (t));
8855                 }
8856             }
8857           else
8858             cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8859                         decl, t);
8860         }
8861     }
8862
8863   TREE_PUBLIC (decl) = publicp;
8864   if (! publicp)
8865     {
8866       DECL_INTERFACE_KNOWN (decl) = 1;
8867       DECL_NOT_REALLY_EXTERN (decl) = 1;
8868     }
8869
8870   /* If the declaration was declared inline, mark it as such.  */
8871   if (inlinep)
8872     DECL_DECLARED_INLINE_P (decl) = 1;
8873   /* We inline functions that are explicitly declared inline, or, when
8874      the user explicitly asks us to, all functions.  */
8875   if (DECL_DECLARED_INLINE_P (decl) || flag_inline_trees == 2)
8876     DECL_INLINE (decl) = 1;
8877
8878   DECL_EXTERNAL (decl) = 1;
8879   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
8880     {
8881       cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8882                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
8883       quals = NULL_TREE;
8884     }
8885
8886   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
8887     grok_op_properties (decl, virtualp, check < 0);
8888
8889   if (ctype && decl_function_context (decl))
8890     DECL_NO_STATIC_CHAIN (decl) = 1;
8891
8892   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
8893     if (TREE_PURPOSE (t)
8894         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
8895       {
8896         has_default_arg = 1;
8897         break;
8898       }
8899
8900   if (friendp
8901       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
8902     {
8903       if (funcdef_flag)
8904         cp_error
8905           ("defining explicit specialization `%D' in friend declaration",
8906            orig_declarator);
8907       else
8908         {
8909           tree fns = TREE_OPERAND (orig_declarator, 0);
8910           tree args = TREE_OPERAND (orig_declarator, 1);
8911
8912           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8913             {
8914               /* Something like `template <class T> friend void f<T>()'.  */
8915               cp_error ("invalid use of template-id `%D' in declaration of primary template",
8916                         orig_declarator);
8917               return NULL_TREE;
8918             }
8919
8920
8921           /* A friend declaration of the form friend void f<>().  Record
8922              the information in the TEMPLATE_ID_EXPR.  */
8923           SET_DECL_IMPLICIT_INSTANTIATION (decl);
8924
8925           if (TREE_CODE (fns) == COMPONENT_REF)
8926             {
8927               /* Due to bison parser ickiness, we will have already looked
8928                  up an operator_name or PFUNCNAME within the current class
8929                  (see template_id in parse.y). If the current class contains
8930                  such a name, we'll get a COMPONENT_REF here. Undo that. */
8931
8932               my_friendly_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
8933                                   == current_class_type, 20001120);
8934               fns = TREE_OPERAND (fns, 1);
8935             }
8936           my_friendly_assert (TREE_CODE (fns) == IDENTIFIER_NODE
8937                               || TREE_CODE (fns) == LOOKUP_EXPR
8938                               || TREE_CODE (fns) == OVERLOAD, 20001120);
8939           DECL_TEMPLATE_INFO (decl) = tree_cons (fns, args, NULL_TREE);
8940
8941           if (has_default_arg)
8942             {
8943               cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8944                         decl);
8945               return NULL_TREE;
8946             }
8947
8948           if (inlinep)
8949             {
8950               cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
8951                         decl);
8952               return NULL_TREE;
8953             }
8954         }
8955     }
8956
8957   if (has_default_arg)
8958     add_defarg_fn (decl);
8959
8960   if (funcdef_flag)
8961     /* Make the init_value nonzero so pushdecl knows this is not
8962        tentative.  error_mark_node is replaced later with the BLOCK.  */
8963     DECL_INITIAL (decl) = error_mark_node;
8964
8965   if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
8966     TREE_NOTHROW (decl) = 1;
8967
8968   /* Caller will do the rest of this.  */
8969   if (check < 0)
8970     return decl;
8971
8972   if (flags == NO_SPECIAL && ctype && constructor_name (ctype) == declarator)
8973     DECL_CONSTRUCTOR_P (decl) = 1;
8974
8975   /* Function gets the ugly name, field gets the nice one.  This call
8976      may change the type of the function (because of default
8977      parameters)!  */
8978   if (ctype != NULL_TREE)
8979     grokclassfn (ctype, decl, flags, quals);
8980
8981   decl = check_explicit_specialization (orig_declarator, decl,
8982                                         template_count,
8983                                         2 * (funcdef_flag != 0) +
8984                                         4 * (friendp != 0));
8985   if (decl == error_mark_node)
8986     return NULL_TREE;
8987
8988   if (ctype != NULL_TREE
8989       && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
8990       && check)
8991     {
8992       tree old_decl;
8993
8994       old_decl = check_classfn (ctype, decl);
8995
8996       if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
8997         /* Because grokfndecl is always supposed to return a
8998            FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
8999            here.  We depend on our callers to figure out that its
9000            really a template that's being returned.  */
9001         old_decl = DECL_TEMPLATE_RESULT (old_decl);
9002
9003       if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
9004           && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
9005         {
9006           /* Remove the `this' parm added by grokclassfn.
9007              XXX Isn't this done in start_function, too?  */
9008           revert_static_member_fn (decl);
9009           last_function_parms = TREE_CHAIN (last_function_parms);
9010         }
9011       if (old_decl && DECL_ARTIFICIAL (old_decl))
9012         cp_error ("definition of implicitly-declared `%D'", old_decl);
9013
9014       if (old_decl)
9015         {
9016           /* Since we've smashed OLD_DECL to its
9017              DECL_TEMPLATE_RESULT, we must do the same to DECL.  */
9018           if (TREE_CODE (decl) == TEMPLATE_DECL)
9019             decl = DECL_TEMPLATE_RESULT (decl);
9020
9021           /* Attempt to merge the declarations.  This can fail, in
9022              the case of some illegal specialization declarations.  */
9023           if (!duplicate_decls (decl, old_decl))
9024             cp_error ("no `%#D' member function declared in class `%T'",
9025                       decl, ctype);
9026           return old_decl;
9027         }
9028     }
9029
9030   if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
9031     return NULL_TREE;
9032
9033   if (ctype == NULL_TREE || check)
9034     return decl;
9035
9036   if (virtualp)
9037     DECL_VIRTUAL_P (decl) = 1;
9038
9039   return decl;
9040 }
9041
9042 static tree
9043 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
9044      tree type;
9045      tree declarator;
9046      RID_BIT_TYPE *specbits_in;
9047      int initialized;
9048      int constp;
9049      tree in_namespace;
9050 {
9051   tree decl;
9052   RID_BIT_TYPE specbits;
9053
9054   specbits = *specbits_in;
9055
9056   if (TREE_CODE (type) == OFFSET_TYPE)
9057     {
9058       /* If you declare a static member so that it
9059          can be initialized, the code will reach here.  */
9060       tree basetype = TYPE_OFFSET_BASETYPE (type);
9061       type = TREE_TYPE (type);
9062       decl = build_lang_decl (VAR_DECL, declarator, type);
9063       DECL_CONTEXT (decl) = basetype;
9064     }
9065   else
9066     {
9067       tree context;
9068
9069       if (in_namespace)
9070         context = in_namespace;
9071       else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
9072         context = current_namespace;
9073       else
9074         context = NULL_TREE;
9075
9076       /* For namespace-scope variables, declared in a template, we
9077          need the full lang_decl.  The same is true for
9078          namespace-scope variables that do not have C++ language
9079          linkage.  */
9080       if (context
9081           && (processing_template_decl
9082               || current_lang_name != lang_name_cplusplus))
9083         decl = build_lang_decl (VAR_DECL, declarator, type);
9084       else
9085         decl = build_decl (VAR_DECL, declarator, type);
9086
9087       if (context)
9088         set_decl_namespace (decl, context, 0);
9089
9090       context = DECL_CONTEXT (decl);
9091       if (declarator && context && current_lang_name != lang_name_c)
9092         /* We can't mangle lazily here because we don't have any
9093            way to recover whether or not a variable was `extern
9094            "C"' later.  */
9095         mangle_decl (decl);
9096     }
9097
9098   if (in_namespace)
9099     set_decl_namespace (decl, in_namespace, 0);
9100
9101   if (RIDBIT_SETP (RID_EXTERN, specbits))
9102     {
9103       DECL_THIS_EXTERN (decl) = 1;
9104       DECL_EXTERNAL (decl) = !initialized;
9105     }
9106
9107   /* In class context, static means one per class,
9108      public access, and static storage.  */
9109   if (DECL_CLASS_SCOPE_P (decl))
9110     {
9111       TREE_PUBLIC (decl) = 1;
9112       TREE_STATIC (decl) = 1;
9113       DECL_EXTERNAL (decl) = 0;
9114     }
9115   /* At top level, either `static' or no s.c. makes a definition
9116      (perhaps tentative), and absence of `static' makes it public.  */
9117   else if (toplevel_bindings_p ())
9118     {
9119       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
9120                             && (DECL_THIS_EXTERN (decl) || ! constp));
9121       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
9122     }
9123   /* Not at top level, only `static' makes a static definition.  */
9124   else
9125     {
9126       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
9127       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
9128     }
9129
9130   if (TREE_PUBLIC (decl))
9131     {
9132       /* [basic.link]: A name with no linkage (notably, the name of a class
9133          or enumeration declared in a local scope) shall not be used to
9134          declare an entity with linkage.
9135
9136          Only check this for public decls for now.  */
9137       tree t = no_linkage_check (TREE_TYPE (decl));
9138       if (t)
9139         {
9140           if (TYPE_ANONYMOUS_P (t))
9141             /* Ignore for now; `enum { foo } e' is pretty common.  */;
9142           else
9143             cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
9144                         decl, t);
9145         }
9146     }
9147
9148   return decl;
9149 }
9150
9151 /* Create and return a canonical pointer to member function type, for
9152    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
9153
9154 tree
9155 build_ptrmemfunc_type (type)
9156      tree type;
9157 {
9158   tree fields[4];
9159   tree t;
9160   tree unqualified_variant = NULL_TREE;
9161
9162   if (type == error_mark_node)
9163     return type;
9164
9165   /* If a canonical type already exists for this type, use it.  We use
9166      this method instead of type_hash_canon, because it only does a
9167      simple equality check on the list of field members.  */
9168
9169   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
9170     return t;
9171
9172   /* Make sure that we always have the unqualified pointer-to-member
9173      type first.  */
9174   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9175     unqualified_variant
9176       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
9177
9178   t = make_aggr_type (RECORD_TYPE);
9179   /* Let the front-end know this is a pointer to member function...  */
9180   TYPE_PTRMEMFUNC_FLAG (t) = 1;
9181   /* ... and not really an aggregate.  */
9182   SET_IS_AGGR_TYPE (t, 0);
9183
9184   fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9185   fields[1] = build_decl (FIELD_DECL, delta_identifier,
9186                           delta_type_node);
9187   finish_builtin_type (t, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9188
9189   /* Zap out the name so that the back-end will give us the debugging
9190      information for this anonymous RECORD_TYPE.  */
9191   TYPE_NAME (t) = NULL_TREE;
9192
9193   /* If this is not the unqualified form of this pointer-to-member
9194      type, set the TYPE_MAIN_VARIANT for this type to be the
9195      unqualified type.  Since they are actually RECORD_TYPEs that are
9196      not variants of each other, we must do this manually.  */
9197   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9198     {
9199       t = build_qualified_type (t, CP_TYPE_QUALS (type));
9200       TYPE_MAIN_VARIANT (t) = unqualified_variant;
9201       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
9202       TYPE_NEXT_VARIANT (unqualified_variant) = t;
9203     }
9204
9205   /* Cache this pointer-to-member type so that we can find it again
9206      later.  */
9207   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
9208
9209   /* Seems to be wanted.  */
9210   CLASSTYPE_GOT_SEMICOLON (t) = 1;
9211
9212   return t;
9213 }
9214
9215 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9216    Check to see that the definition is valid.  Issue appropriate error
9217    messages.  Return 1 if the definition is particularly bad, or 0
9218    otherwise.  */
9219
9220 int
9221 check_static_variable_definition (decl, type)
9222      tree decl;
9223      tree type;
9224 {
9225   /* Motion 10 at San Diego: If a static const integral data member is
9226      initialized with an integral constant expression, the initializer
9227      may appear either in the declaration (within the class), or in
9228      the definition, but not both.  If it appears in the class, the
9229      member is a member constant.  The file-scope definition is always
9230      required.  */
9231   if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
9232     {
9233       cp_error ("invalid in-class initialization of static data member of non-integral type `%T'",
9234                 type);
9235       /* If we just return the declaration, crashes will sometimes
9236          occur.  We therefore return void_type_node, as if this was a
9237          friend declaration, to cause callers to completely ignore
9238          this declaration.  */
9239       return 1;
9240     }
9241   else if (!CP_TYPE_CONST_P (type))
9242     cp_error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9243               decl);
9244   else if (pedantic && !INTEGRAL_TYPE_P (type))
9245     cp_pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
9246
9247   return 0;
9248 }
9249
9250 /* Given the SIZE (i.e., number of elements) in an array, compute an
9251    appropriate index type for the array.  If non-NULL, NAME is the
9252    name of the thing being declared.  */
9253
9254 tree
9255 compute_array_index_type (name, size)
9256      tree name;
9257      tree size;
9258 {
9259   tree itype;
9260
9261   /* If this involves a template parameter, it will be a constant at
9262      instantiation time, but we don't know what the value is yet.
9263      Even if no template parameters are involved, we may an expression
9264      that is not a constant; we don't even simplify `1 + 2' when
9265      processing a template.  */
9266   if (processing_template_decl)
9267     {
9268       /* Resolve a qualified reference to an enumerator or static
9269          const data member of ours.  */
9270       if (TREE_CODE (size) == SCOPE_REF
9271           && TREE_OPERAND (size, 0) == current_class_type)
9272         {
9273           tree t = lookup_field (current_class_type,
9274                                  TREE_OPERAND (size, 1), 0, 0);
9275           if (t)
9276             size = t;
9277         }
9278
9279       return build_index_type (build_min (MINUS_EXPR, sizetype,
9280                                           size, integer_one_node));
9281     }
9282
9283   /* The size might be the result of a cast. */
9284   STRIP_TYPE_NOPS (size);
9285
9286   /* It might be a const variable or enumeration constant.  */
9287   size = decl_constant_value (size);
9288
9289   /* The array bound must be an integer type.  */
9290   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9291       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
9292       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
9293     {
9294       if (name)
9295         cp_error ("size of array `%D' has non-integer type", name);
9296       else
9297         cp_error ("size of array has non-integer type");
9298       size = integer_one_node;
9299     }
9300
9301   /* Normally, the array-bound will be a constant.  */
9302   if (TREE_CODE (size) == INTEGER_CST)
9303     {
9304       /* Check to see if the array bound overflowed.  Make that an
9305          error, no matter how generous we're being.  */
9306       int old_flag_pedantic_errors = flag_pedantic_errors;
9307       int old_pedantic = pedantic;
9308       pedantic = flag_pedantic_errors = 1;
9309       constant_expression_warning (size);
9310       pedantic = old_pedantic;
9311       flag_pedantic_errors = old_flag_pedantic_errors;
9312
9313       /* An array must have a positive number of elements.  */
9314       if (INT_CST_LT (size, integer_zero_node))
9315         {
9316           if (name)
9317             cp_error ("size of array `%D' is negative", name);
9318           else
9319             cp_error ("size of array is negative");
9320           size = integer_one_node;
9321         }
9322       /* Except that an extension we allow zero-sized arrays.  We
9323          always allow them in system headers because glibc uses
9324          them.  */
9325       else if (integer_zerop (size) && pedantic && !in_system_header)
9326         {
9327           if (name)
9328             cp_pedwarn ("ISO C++ forbids zero-size array `%D'", name);
9329           else
9330             cp_pedwarn ("ISO C++ forbids zero-size array");
9331         }
9332     }
9333   else if (TREE_CONSTANT (size))
9334     {
9335       /* `(int) &fn' is not a valid array bound.  */
9336       if (name)
9337         cp_error ("size of array `%D' is not an integral constant-expression",
9338                   name);
9339       else
9340         cp_error ("size of array is not an integral constant-expression");
9341     }
9342
9343   /* Compute the index of the largest element in the array.  It is
9344      one less than the number of elements in the array.  */
9345   itype
9346     = fold (cp_build_binary_op (MINUS_EXPR,
9347                                 cp_convert (ssizetype, size),
9348                                 cp_convert (ssizetype,
9349                                             integer_one_node)));
9350
9351   /* Check for variable-sized arrays.  We allow such things as an
9352      extension, even though they are not allowed in ANSI/ISO C++.  */
9353   if (!TREE_CONSTANT (itype))
9354     {
9355       if (pedantic)
9356         {
9357           if (name)
9358             cp_pedwarn ("ISO C++ forbids variable-size array `%D'",
9359                         name);
9360           else
9361             cp_pedwarn ("ISO C++ forbids variable-size array");
9362         }
9363
9364       /* Create a variable-sized array index type.  */
9365       itype = variable_size (itype);
9366     }
9367   /* Make sure that there was no overflow when creating to a signed
9368      index type.  (For example, on a 32-bit machine, an array with
9369      size 2^32 - 1 is too big.)  */
9370   else if (TREE_OVERFLOW (itype))
9371     {
9372       error ("overflow in array dimension");
9373       TREE_OVERFLOW (itype) = 0;
9374     }
9375
9376   /* Create and return the appropriate index type.  */
9377   return build_index_type (itype);
9378 }
9379
9380 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9381    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
9382    with this type.  */
9383
9384 static tree
9385 create_array_type_for_decl (name, type, size)
9386      tree name;
9387      tree type;
9388      tree size;
9389 {
9390   tree itype = NULL_TREE;
9391   const char* error_msg;
9392
9393   /* If things have already gone awry, bail now.  */
9394   if (type == error_mark_node || size == error_mark_node)
9395     return error_mark_node;
9396
9397   /* Assume that everything will go OK.  */
9398   error_msg = NULL;
9399
9400   /* There are some types which cannot be array elements.  */
9401   switch (TREE_CODE (type))
9402     {
9403     case VOID_TYPE:
9404       error_msg = "array of void";
9405       break;
9406
9407     case FUNCTION_TYPE:
9408       error_msg = "array of functions";
9409       break;
9410
9411     case REFERENCE_TYPE:
9412       error_msg = "array of references";
9413       break;
9414
9415     case OFFSET_TYPE:
9416       error_msg = "array of data members";
9417       break;
9418
9419     case METHOD_TYPE:
9420       error_msg = "array of function members";
9421       break;
9422
9423     default:
9424       break;
9425     }
9426
9427   /* If something went wrong, issue an error-message and return.  */
9428   if (error_msg)
9429     {
9430       if (name)
9431         cp_error ("declaration of `%D' as %s", name, error_msg);
9432       else
9433         cp_error ("creating %s", error_msg);
9434
9435       return error_mark_node;
9436     }
9437
9438   /* [dcl.array]
9439
9440      The constant expressions that specify the bounds of the arrays
9441      can be omitted only for the first member of the sequence.  */
9442   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9443     {
9444       cp_error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9445                 name);
9446
9447       return error_mark_node;
9448     }
9449
9450   /* Figure out the index type for the array.  */
9451   if (size)
9452     itype = compute_array_index_type (name, size);
9453
9454   return build_cplus_array_type (type, itype);
9455 }
9456
9457 /* Check that it's OK to declare a function with the indicated TYPE.
9458    SFK indicates the kind of special function (if any) that this
9459    function is.  OPTYPE is the type given in a conversion operator
9460    declaration.  Returns the actual return type of the function; that
9461    may be different than TYPE if an error occurs, or for certain
9462    special functions.  */
9463
9464 static tree
9465 check_special_function_return_type (sfk, type, optype)
9466      special_function_kind sfk;
9467      tree type;
9468      tree optype;
9469 {
9470   switch (sfk)
9471     {
9472     case sfk_constructor:
9473       if (type)
9474         cp_error ("return type specification for constructor invalid");
9475
9476       /* In the new ABI constructors do not return a value.  */
9477       type = void_type_node;
9478       break;
9479
9480     case sfk_destructor:
9481       if (type)
9482         cp_error ("return type specification for destructor invalid");
9483       type = void_type_node;
9484       break;
9485
9486     case sfk_conversion:
9487       if (type && !same_type_p (type, optype))
9488         cp_error ("operator `%T' declared to return `%T'", optype, type);
9489       else if (type)
9490         cp_pedwarn ("return type specified for `operator %T'",  optype);
9491       type = optype;
9492       break;
9493
9494     default:
9495       my_friendly_abort (20000408);
9496       break;
9497     }
9498
9499   return type;
9500 }
9501
9502 /* Given declspecs and a declarator,
9503    determine the name and type of the object declared
9504    and construct a ..._DECL node for it.
9505    (In one case we can return a ..._TYPE node instead.
9506     For invalid input we sometimes return 0.)
9507
9508    DECLSPECS is a chain of tree_list nodes whose value fields
9509     are the storage classes and type specifiers.
9510
9511    DECL_CONTEXT says which syntactic context this declaration is in:
9512      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9513      FUNCDEF for a function definition.  Like NORMAL but a few different
9514       error messages in each case.  Return value may be zero meaning
9515       this definition is too screwy to try to parse.
9516      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
9517       handle member functions (which have FIELD context).
9518       Return value may be zero meaning this definition is too screwy to
9519       try to parse.
9520      PARM for a parameter declaration (either within a function prototype
9521       or before a function body).  Make a PARM_DECL, or return void_type_node.
9522      CATCHPARM for a parameter declaration before a catch clause.
9523      TYPENAME if for a typename (in a cast or sizeof).
9524       Don't make a DECL node; just return the ..._TYPE node.
9525      FIELD for a struct or union field; make a FIELD_DECL.
9526      BITFIELD for a field with specified width.
9527    INITIALIZED is 1 if the decl has an initializer.
9528
9529    ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
9530    normal attributes in TREE_PURPOSE, or NULL_TREE.
9531
9532    In the TYPENAME case, DECLARATOR is really an abstract declarator.
9533    It may also be so in the PARM case, for a prototype where the
9534    argument type is specified but not the name.
9535
9536    This function is where the complicated C meanings of `static'
9537    and `extern' are interpreted.
9538
9539    For C++, if there is any monkey business to do, the function which
9540    calls this one must do it, i.e., prepending instance variables,
9541    renaming overloaded function names, etc.
9542
9543    Note that for this C++, it is an error to define a method within a class
9544    which does not belong to that class.
9545
9546    Except in the case where SCOPE_REFs are implicitly known (such as
9547    methods within a class being redundantly qualified),
9548    declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9549    (class_name::decl_name).  The caller must also deal with this.
9550
9551    If a constructor or destructor is seen, and the context is FIELD,
9552    then the type gains the attribute TREE_HAS_x.  If such a declaration
9553    is erroneous, NULL_TREE is returned.
9554
9555    QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
9556    function, these are the qualifiers to give to the `this' pointer. We
9557    apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9558
9559    May return void_type_node if the declarator turned out to be a friend.
9560    See grokfield for details.  */
9561
9562 tree
9563 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9564      tree declspecs;
9565      tree declarator;
9566      enum decl_context decl_context;
9567      int initialized;
9568      tree attrlist;
9569 {
9570   RID_BIT_TYPE specbits;
9571   int nclasses = 0;
9572   tree spec;
9573   tree type = NULL_TREE;
9574   int longlong = 0;
9575   int constp;
9576   int restrictp;
9577   int volatilep;
9578   int type_quals;
9579   int virtualp, explicitp, friendp, inlinep, staticp;
9580   int explicit_int = 0;
9581   int explicit_char = 0;
9582   int defaulted_int = 0;
9583   tree typedef_decl = NULL_TREE;
9584   const char *name;
9585   tree typedef_type = NULL_TREE;
9586   int funcdef_flag = 0;
9587   enum tree_code innermost_code = ERROR_MARK;
9588   int bitfield = 0;
9589 #if 0
9590   /* See the code below that used this.  */
9591   tree decl_machine_attr = NULL_TREE;
9592 #endif
9593   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9594      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9595   tree init = NULL_TREE;
9596
9597   /* Keep track of what sort of function is being processed
9598      so that we can warn about default return values, or explicit
9599      return values which do not match prescribed defaults.  */
9600   special_function_kind sfk = sfk_none;
9601
9602   tree dname = NULL_TREE;
9603   tree ctype = current_class_type;
9604   tree ctor_return_type = NULL_TREE;
9605   enum overload_flags flags = NO_SPECIAL;
9606   tree quals = NULL_TREE;
9607   tree raises = NULL_TREE;
9608   int template_count = 0;
9609   tree in_namespace = NULL_TREE;
9610   tree inner_attrs;
9611   int ignore_attrs;
9612
9613   RIDBIT_RESET_ALL (specbits);
9614   if (decl_context == FUNCDEF)
9615     funcdef_flag = 1, decl_context = NORMAL;
9616   else if (decl_context == MEMFUNCDEF)
9617     funcdef_flag = -1, decl_context = FIELD;
9618   else if (decl_context == BITFIELD)
9619     bitfield = 1, decl_context = FIELD;
9620
9621   /* Look inside a declarator for the name being declared
9622      and get it as a string, for an error message.  */
9623   {
9624     tree *next = &declarator;
9625     register tree decl;
9626     name = NULL;
9627
9628     while (next && *next)
9629       {
9630         decl = *next;
9631         switch (TREE_CODE (decl))
9632           {
9633           case TREE_LIST:
9634             /* For attributes.  */
9635             next = &TREE_VALUE (decl);
9636             break;
9637
9638           case COND_EXPR:
9639             ctype = NULL_TREE;
9640             next = &TREE_OPERAND (decl, 0);
9641             break;
9642
9643           case BIT_NOT_EXPR:    /* For C++ destructors!  */
9644             {
9645               tree name = TREE_OPERAND (decl, 0);
9646               tree rename = NULL_TREE;
9647
9648               my_friendly_assert (flags == NO_SPECIAL, 152);
9649               flags = DTOR_FLAG;
9650               sfk = sfk_destructor;
9651               if (TREE_CODE (name) == TYPE_DECL)
9652                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9653               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9654               if (ctype == NULL_TREE)
9655                 {
9656                   if (current_class_type == NULL_TREE)
9657                     {
9658                       error ("destructors must be member functions");
9659                       flags = NO_SPECIAL;
9660                     }
9661                   else
9662                     {
9663                       tree t = constructor_name (current_class_name);
9664                       if (t != name)
9665                         rename = t;
9666                     }
9667                 }
9668               else
9669                 {
9670                   tree t = constructor_name (ctype);
9671                   if (t != name)
9672                     rename = t;
9673                 }
9674
9675               if (rename)
9676                 {
9677                   cp_error ("destructor `%T' must match class name `%T'",
9678                             name, rename);
9679                   TREE_OPERAND (decl, 0) = rename;
9680                 }
9681               next = &name;
9682             }
9683             break;
9684
9685           case ADDR_EXPR:       /* C++ reference declaration */
9686             /* Fall through. */
9687           case ARRAY_REF:
9688           case INDIRECT_REF:
9689             ctype = NULL_TREE;
9690             innermost_code = TREE_CODE (decl);
9691             next = &TREE_OPERAND (decl, 0);
9692             break;
9693
9694           case CALL_EXPR:
9695             if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
9696               {
9697                 /* This is actually a variable declaration using
9698                    constructor syntax.  We need to call start_decl and
9699                    cp_finish_decl so we can get the variable
9700                    initialized...  */
9701
9702                 tree attributes, prefix_attributes;
9703
9704                 *next = TREE_OPERAND (decl, 0);
9705                 init = CALL_DECLARATOR_PARMS (decl);
9706
9707                 if (attrlist)
9708                   {
9709                     attributes = TREE_PURPOSE (attrlist);
9710                     prefix_attributes = TREE_VALUE (attrlist);
9711                   }
9712                 else
9713                   {
9714                     attributes = NULL_TREE;
9715                     prefix_attributes = NULL_TREE;
9716                   }
9717
9718                 decl = start_decl (declarator, declspecs, 1,
9719                                    attributes, prefix_attributes);
9720                 decl_type_access_control (decl);
9721                 if (decl)
9722                   {
9723                     /* Look for __unused__ attribute */
9724                     if (TREE_USED (TREE_TYPE (decl)))
9725                       TREE_USED (decl) = 1;
9726                     finish_decl (decl, init, NULL_TREE);
9727                   }
9728                 else
9729                   cp_error ("invalid declarator");
9730                 return 0;
9731               }
9732             innermost_code = TREE_CODE (decl);
9733             if (decl_context == FIELD && ctype == NULL_TREE)
9734               ctype = current_class_type;
9735             if (ctype
9736                 && TREE_OPERAND (decl, 0)
9737                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9738                     && ((DECL_NAME (TREE_OPERAND (decl, 0))
9739                          == constructor_name_full (ctype))
9740                         || (DECL_NAME (TREE_OPERAND (decl, 0))
9741                             == constructor_name (ctype)))))
9742               TREE_OPERAND (decl, 0) = constructor_name (ctype);
9743             next = &TREE_OPERAND (decl, 0);
9744             decl = *next;
9745             if (ctype != NULL_TREE
9746                 && decl != NULL_TREE && flags != DTOR_FLAG
9747                 && decl == constructor_name (ctype))
9748               {
9749                 sfk = sfk_constructor;
9750                 ctor_return_type = ctype;
9751               }
9752             ctype = NULL_TREE;
9753             break;
9754
9755           case TEMPLATE_ID_EXPR:
9756               {
9757                 tree fns = TREE_OPERAND (decl, 0);
9758
9759                 if (TREE_CODE (fns) == LOOKUP_EXPR)
9760                   fns = TREE_OPERAND (fns, 0);
9761
9762                 dname = fns;
9763                 if (TREE_CODE (dname) == COMPONENT_REF)
9764                   dname = TREE_OPERAND (dname, 1);
9765                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9766                   {
9767                     my_friendly_assert (is_overloaded_fn (dname),
9768                                         19990331);
9769                     dname = DECL_NAME (get_first_fn (dname));
9770                   }
9771               }
9772           /* Fall through. */
9773
9774           case IDENTIFIER_NODE:
9775             if (TREE_CODE (decl) == IDENTIFIER_NODE)
9776               dname = decl;
9777
9778             next = 0;
9779
9780             if (C_IS_RESERVED_WORD (dname))
9781               {
9782                 cp_error ("declarator-id missing; using reserved word `%D'",
9783                           dname);
9784                 name = IDENTIFIER_POINTER (dname);
9785               }
9786             else if (!IDENTIFIER_TYPENAME_P (dname))
9787               name = IDENTIFIER_POINTER (dname);
9788             else
9789               {
9790                 my_friendly_assert (flags == NO_SPECIAL, 154);
9791                 flags = TYPENAME_FLAG;
9792                 ctor_return_type = TREE_TYPE (dname);
9793                 sfk = sfk_conversion;
9794                 if (IDENTIFIER_GLOBAL_VALUE (dname)
9795                     && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (dname))
9796                         == TYPE_DECL))
9797                   name = IDENTIFIER_POINTER (dname);
9798                 else
9799                   name = "<invalid operator>";
9800               }
9801             break;
9802
9803             /* C++ extension */
9804           case SCOPE_REF:
9805             {
9806               /* Perform error checking, and decide on a ctype.  */
9807               tree cname = TREE_OPERAND (decl, 0);
9808               if (cname == NULL_TREE)
9809                 ctype = NULL_TREE;
9810               else if (TREE_CODE (cname) == NAMESPACE_DECL)
9811                 {
9812                   ctype = NULL_TREE;
9813                   in_namespace = TREE_OPERAND (decl, 0);
9814                   TREE_OPERAND (decl, 0) = NULL_TREE;
9815                 }
9816               else if (! is_aggr_type (cname, 1))
9817                 TREE_OPERAND (decl, 0) = NULL_TREE;
9818               /* Must test TREE_OPERAND (decl, 1), in case user gives
9819                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
9820               else if (TREE_OPERAND (decl, 1)
9821                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9822                 ctype = cname;
9823               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9824                        || TREE_CODE (cname) == BOUND_TEMPLATE_TEMPLATE_PARM)
9825                 {
9826                   cp_error ("`%T::%D' is not a valid declarator", cname,
9827                             TREE_OPERAND (decl, 1));
9828                   cp_error ("  perhaps you want `typename %T::%D' to make it a type",
9829                             cname, TREE_OPERAND (decl, 1));
9830                   return void_type_node;
9831                 }
9832               else if (ctype == NULL_TREE)
9833                 ctype = cname;
9834               else if (TREE_COMPLEXITY (decl) == current_class_depth)
9835                 TREE_OPERAND (decl, 0) = ctype;
9836               else
9837                 {
9838                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9839                     {
9840                       cp_error ("type `%T' is not derived from type `%T'",
9841                                 cname, ctype);
9842                       TREE_OPERAND (decl, 0) = NULL_TREE;
9843                     }
9844                   else
9845                     ctype = cname;
9846                 }
9847
9848               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
9849                   && ((DECL_NAME (TREE_OPERAND (decl, 1))
9850                        == constructor_name_full (ctype))
9851                       || (DECL_NAME (TREE_OPERAND (decl, 1))
9852                           == constructor_name (ctype))))
9853                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
9854               next = &TREE_OPERAND (decl, 1);
9855               decl = *next;
9856               if (ctype)
9857                 {
9858                   if (TREE_CODE (decl) == IDENTIFIER_NODE
9859                       && constructor_name (ctype) == decl)
9860                     {
9861                       sfk = sfk_constructor;
9862                       ctor_return_type = ctype;
9863                     }
9864                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
9865                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
9866                            && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
9867                                || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
9868                     {
9869                       sfk = sfk_destructor;
9870                       ctor_return_type = ctype;
9871                       flags = DTOR_FLAG;
9872                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
9873                       next = &TREE_OPERAND (decl, 0);
9874                     }
9875                 }
9876             }
9877             break;
9878
9879           case ERROR_MARK:
9880             next = 0;
9881             break;
9882
9883           case TYPE_DECL:
9884             /* Parse error puts this typespec where
9885                a declarator should go.  */
9886             cp_error ("`%T' specified as declarator-id", DECL_NAME (decl));
9887             if (TREE_TYPE (decl) == current_class_type)
9888               cp_error ("  perhaps you want `%T' for a constructor",
9889                         current_class_name);
9890             dname = DECL_NAME (decl);
9891             name = IDENTIFIER_POINTER (dname);
9892
9893             /* Avoid giving two errors for this.  */
9894             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
9895
9896             declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
9897             *next = dname;
9898             next = 0;
9899             break;
9900
9901           default:
9902             cp_compiler_error ("`%D' as declarator", decl);
9903             return 0; /* We used to do a 155 abort here.  */
9904           }
9905       }
9906   }
9907
9908   /* A function definition's declarator must have the form of
9909      a function declarator.  */
9910
9911   if (funcdef_flag && innermost_code != CALL_EXPR)
9912     return 0;
9913
9914   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
9915       && innermost_code != CALL_EXPR
9916       && ! (ctype && declspecs == NULL_TREE))
9917     {
9918       cp_error ("declaration of `%D' as non-function", dname);
9919       return void_type_node;
9920     }
9921
9922   /* Anything declared one level down from the top level
9923      must be one of the parameters of a function
9924      (because the body is at least two levels down).  */
9925
9926   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9927      by not allowing C++ class definitions to specify their parameters
9928      with xdecls (must be spec.d in the parmlist).
9929
9930      Since we now wait to push a class scope until we are sure that
9931      we are in a legitimate method context, we must set oldcname
9932      explicitly (since current_class_name is not yet alive).
9933
9934      We also want to avoid calling this a PARM if it is in a namespace.  */
9935
9936   if (decl_context == NORMAL && !toplevel_bindings_p ())
9937     {
9938       struct binding_level *b = current_binding_level;
9939       current_binding_level = b->level_chain;
9940       if (current_binding_level != 0 && toplevel_bindings_p ())
9941         decl_context = PARM;
9942       current_binding_level = b;
9943     }
9944
9945   if (name == NULL)
9946     name = decl_context == PARM ? "parameter" : "type name";
9947
9948   /* Look through the decl specs and record which ones appear.
9949      Some typespecs are defined as built-in typenames.
9950      Others, the ones that are modifiers of other types,
9951      are represented by bits in SPECBITS: set the bits for
9952      the modifiers that appear.  Storage class keywords are also in SPECBITS.
9953
9954      If there is a typedef name or a type, store the type in TYPE.
9955      This includes builtin typedefs such as `int'.
9956
9957      Set EXPLICIT_INT if the type is `int' or `char' and did not
9958      come from a user typedef.
9959
9960      Set LONGLONG if `long' is mentioned twice.
9961
9962      For C++, constructors and destructors have their own fast treatment.  */
9963
9964   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
9965     {
9966       register int i;
9967       register tree id;
9968
9969       /* Certain parse errors slip through.  For example,
9970          `int class;' is not caught by the parser. Try
9971          weakly to recover here.  */
9972       if (TREE_CODE (spec) != TREE_LIST)
9973         return 0;
9974
9975       id = TREE_VALUE (spec);
9976
9977       if (TREE_CODE (id) == IDENTIFIER_NODE)
9978         {
9979           if (id == ridpointers[(int) RID_INT]
9980               || id == ridpointers[(int) RID_CHAR]
9981               || id == ridpointers[(int) RID_BOOL]
9982               || id == ridpointers[(int) RID_WCHAR])
9983             {
9984               if (type)
9985                 {
9986                   if (id == ridpointers[(int) RID_BOOL])
9987                     error ("`bool' is now a keyword");
9988                   else
9989                     cp_error ("extraneous `%T' ignored", id);
9990                 }
9991               else
9992                 {
9993                   if (id == ridpointers[(int) RID_INT])
9994                     explicit_int = 1;
9995                   else if (id == ridpointers[(int) RID_CHAR])
9996                     explicit_char = 1;
9997                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
9998                 }
9999               goto found;
10000             }
10001           /* C++ aggregate types.  */
10002           if (IDENTIFIER_HAS_TYPE_VALUE (id))
10003             {
10004               if (type)
10005                 cp_error ("multiple declarations `%T' and `%T'", type, id);
10006               else
10007                 type = IDENTIFIER_TYPE_VALUE (id);
10008               goto found;
10009             }
10010
10011           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
10012             {
10013               if (ridpointers[i] == id)
10014                 {
10015                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
10016                     {
10017                       if (pedantic && ! in_system_header && warn_long_long)
10018                         pedwarn ("ISO C++ does not support `long long'");
10019                       if (longlong)
10020                         error ("`long long long' is too long for GCC");
10021                       else
10022                         longlong = 1;
10023                     }
10024                   else if (RIDBIT_SETP (i, specbits))
10025                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
10026                   RIDBIT_SET (i, specbits);
10027                   goto found;
10028                 }
10029             }
10030         }
10031       /* C++ aggregate types.  */
10032       else if (TREE_CODE (id) == TYPE_DECL)
10033         {
10034           if (type)
10035             cp_error ("multiple declarations `%T' and `%T'", type,
10036                       TREE_TYPE (id));
10037           else
10038             {
10039               type = TREE_TYPE (id);
10040               TREE_VALUE (spec) = type;
10041             }
10042           goto found;
10043         }
10044       if (type)
10045         error ("two or more data types in declaration of `%s'", name);
10046       else if (TREE_CODE (id) == IDENTIFIER_NODE)
10047         {
10048           register tree t = lookup_name (id, 1);
10049           if (!t || TREE_CODE (t) != TYPE_DECL)
10050             error ("`%s' fails to be a typedef or built in type",
10051                    IDENTIFIER_POINTER (id));
10052           else
10053             {
10054               type = TREE_TYPE (t);
10055 #if 0
10056               /* See the code below that used this.  */
10057               decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
10058 #endif
10059               typedef_decl = t;
10060             }
10061         }
10062       else if (id != error_mark_node)
10063         /* Can't change CLASS nodes into RECORD nodes here!  */
10064         type = id;
10065
10066     found: ;
10067     }
10068
10069   typedef_type = type;
10070
10071   /* No type at all: default to `int', and set DEFAULTED_INT
10072      because it was not a user-defined typedef.  */
10073
10074   if (type == NULL_TREE
10075       && (RIDBIT_SETP (RID_SIGNED, specbits)
10076           || RIDBIT_SETP (RID_UNSIGNED, specbits)
10077           || RIDBIT_SETP (RID_LONG, specbits)
10078           || RIDBIT_SETP (RID_SHORT, specbits)))
10079     {
10080       /* These imply 'int'.  */
10081       type = integer_type_node;
10082       defaulted_int = 1;
10083     }
10084
10085   if (sfk != sfk_none)
10086     type = check_special_function_return_type (sfk, type,
10087                                                ctor_return_type);
10088   else if (type == NULL_TREE)
10089     {
10090       int is_main;
10091
10092       explicit_int = -1;
10093
10094           /* We handle `main' specially here, because 'main () { }' is so
10095              common.  With no options, it is allowed.  With -Wreturn-type,
10096              it is a warning.  It is only an error with -pedantic-errors.  */
10097       is_main = (funcdef_flag
10098                  && MAIN_NAME_P (dname)
10099                  && ctype == NULL_TREE
10100                  && in_namespace == NULL_TREE
10101                  && current_namespace == global_namespace);
10102
10103       if (in_system_header || flag_ms_extensions)
10104         /* Allow it, sigh.  */;
10105       else if (pedantic || ! is_main)
10106         cp_pedwarn ("ISO C++ forbids declaration of `%s' with no type",
10107                     name);
10108       else if (warn_return_type)
10109         cp_warning ("ISO C++ forbids declaration of `%s' with no type",
10110                     name);
10111
10112       type = integer_type_node;
10113     }
10114
10115   ctype = NULL_TREE;
10116
10117   /* Now process the modifiers that were specified
10118      and check for invalid combinations.  */
10119
10120   /* Long double is a special combination.  */
10121
10122   if (RIDBIT_SETP (RID_LONG, specbits)
10123       && TYPE_MAIN_VARIANT (type) == double_type_node)
10124     {
10125       RIDBIT_RESET (RID_LONG, specbits);
10126       type = build_qualified_type (long_double_type_node,
10127                                    CP_TYPE_QUALS (type));
10128     }
10129
10130   /* Check all other uses of type modifiers.  */
10131
10132   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10133       || RIDBIT_SETP (RID_SIGNED, specbits)
10134       || RIDBIT_SETP (RID_LONG, specbits)
10135       || RIDBIT_SETP (RID_SHORT, specbits))
10136     {
10137       int ok = 0;
10138
10139       if (TREE_CODE (type) == REAL_TYPE)
10140         error ("short, signed or unsigned invalid for `%s'", name);
10141       else if (TREE_CODE (type) != INTEGER_TYPE)
10142         error ("long, short, signed or unsigned invalid for `%s'", name);
10143       else if (RIDBIT_SETP (RID_LONG, specbits)
10144                && RIDBIT_SETP (RID_SHORT, specbits))
10145         error ("long and short specified together for `%s'", name);
10146       else if ((RIDBIT_SETP (RID_LONG, specbits)
10147                 || RIDBIT_SETP (RID_SHORT, specbits))
10148                && explicit_char)
10149         error ("long or short specified with char for `%s'", name);
10150       else if ((RIDBIT_SETP (RID_LONG, specbits)
10151                 || RIDBIT_SETP (RID_SHORT, specbits))
10152                && TREE_CODE (type) == REAL_TYPE)
10153         error ("long or short specified with floating type for `%s'", name);
10154       else if (RIDBIT_SETP (RID_SIGNED, specbits)
10155                && RIDBIT_SETP (RID_UNSIGNED, specbits))
10156         error ("signed and unsigned given together for `%s'", name);
10157       else
10158         {
10159           ok = 1;
10160           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
10161             {
10162               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10163                        name);
10164               if (flag_pedantic_errors)
10165                 ok = 0;
10166             }
10167         }
10168
10169       /* Discard the type modifiers if they are invalid.  */
10170       if (! ok)
10171         {
10172           RIDBIT_RESET (RID_UNSIGNED, specbits);
10173           RIDBIT_RESET (RID_SIGNED, specbits);
10174           RIDBIT_RESET (RID_LONG, specbits);
10175           RIDBIT_RESET (RID_SHORT, specbits);
10176           longlong = 0;
10177         }
10178     }
10179
10180   if (RIDBIT_SETP (RID_COMPLEX, specbits)
10181       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
10182     {
10183       error ("complex invalid for `%s'", name);
10184       RIDBIT_RESET (RID_COMPLEX, specbits);
10185     }
10186
10187   /* Decide whether an integer type is signed or not.
10188      Optionally treat bitfields as signed by default.  */
10189   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10190       /* [class.bit]
10191
10192          It is implementation-defined whether a plain (neither
10193          explicitly signed or unsigned) char, short, int, or long
10194          bit-field is signed or unsigned.
10195
10196          Naturally, we extend this to long long as well.  Note that
10197          this does not include wchar_t.  */
10198       || (bitfield && !flag_signed_bitfields
10199           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
10200           /* A typedef for plain `int' without `signed' can be
10201              controlled just like plain `int', but a typedef for
10202              `signed int' cannot be so controlled.  */
10203           && !(typedef_decl
10204                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
10205           && (TREE_CODE (type) == INTEGER_TYPE
10206               || TREE_CODE (type) == CHAR_TYPE)
10207           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
10208     {
10209       if (longlong)
10210         type = long_long_unsigned_type_node;
10211       else if (RIDBIT_SETP (RID_LONG, specbits))
10212         type = long_unsigned_type_node;
10213       else if (RIDBIT_SETP (RID_SHORT, specbits))
10214         type = short_unsigned_type_node;
10215       else if (type == char_type_node)
10216         type = unsigned_char_type_node;
10217       else if (typedef_decl)
10218         type = unsigned_type (type);
10219       else
10220         type = unsigned_type_node;
10221     }
10222   else if (RIDBIT_SETP (RID_SIGNED, specbits)
10223            && type == char_type_node)
10224     type = signed_char_type_node;
10225   else if (longlong)
10226     type = long_long_integer_type_node;
10227   else if (RIDBIT_SETP (RID_LONG, specbits))
10228     type = long_integer_type_node;
10229   else if (RIDBIT_SETP (RID_SHORT, specbits))
10230     type = short_integer_type_node;
10231
10232   if (RIDBIT_SETP (RID_COMPLEX, specbits))
10233     {
10234       /* If we just have "complex", it is equivalent to
10235          "complex double", but if any modifiers at all are specified it is
10236          the complex form of TYPE.  E.g, "complex short" is
10237          "complex short int".  */
10238
10239       if (defaulted_int && ! longlong
10240           && ! (RIDBIT_SETP (RID_LONG, specbits)
10241                 || RIDBIT_SETP (RID_SHORT, specbits)
10242                 || RIDBIT_SETP (RID_SIGNED, specbits)
10243                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
10244         type = complex_double_type_node;
10245       else if (type == integer_type_node)
10246         type = complex_integer_type_node;
10247       else if (type == float_type_node)
10248         type = complex_float_type_node;
10249       else if (type == double_type_node)
10250         type = complex_double_type_node;
10251       else if (type == long_double_type_node)
10252         type = complex_long_double_type_node;
10253       else
10254         type = build_complex_type (type);
10255     }
10256
10257   if (sfk == sfk_conversion
10258       && (RIDBIT_SETP (RID_CONST, specbits)
10259           || RIDBIT_SETP (RID_VOLATILE, specbits)
10260           || RIDBIT_SETP (RID_RESTRICT, specbits)))
10261     cp_error ("qualifiers are not allowed on declaration of `operator %T'",
10262               ctor_return_type);
10263
10264   /* Set CONSTP if this declaration is `const', whether by
10265      explicit specification or via a typedef.
10266      Likewise for VOLATILEP.  */
10267
10268   constp = !! RIDBIT_SETP (RID_CONST, specbits) + CP_TYPE_CONST_P (type);
10269   restrictp =
10270     !! RIDBIT_SETP (RID_RESTRICT, specbits) + CP_TYPE_RESTRICT_P (type);
10271   volatilep =
10272     !! RIDBIT_SETP (RID_VOLATILE, specbits) + CP_TYPE_VOLATILE_P (type);
10273   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10274                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10275                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10276   type = cp_build_qualified_type (type, type_quals);
10277   staticp = 0;
10278   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
10279   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
10280   RIDBIT_RESET (RID_VIRTUAL, specbits);
10281   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
10282   RIDBIT_RESET (RID_EXPLICIT, specbits);
10283
10284   if (RIDBIT_SETP (RID_STATIC, specbits))
10285     staticp = 1 + (decl_context == FIELD);
10286
10287   if (virtualp && staticp == 2)
10288     {
10289       cp_error ("member `%D' cannot be declared both virtual and static",
10290                 dname);
10291       staticp = 0;
10292     }
10293   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
10294   RIDBIT_RESET (RID_FRIEND, specbits);
10295
10296   /* Warn if two storage classes are given. Default to `auto'.  */
10297
10298   if (RIDBIT_ANY_SET (specbits))
10299     {
10300       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
10301       if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
10302       if (decl_context == PARM && nclasses > 0)
10303         error ("storage class specifiers invalid in parameter declarations");
10304       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10305         {
10306           if (decl_context == PARM)
10307             error ("typedef declaration invalid in parameter declaration");
10308           nclasses++;
10309         }
10310       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
10311       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
10312     }
10313
10314   /* Give error if `virtual' is used outside of class declaration.  */
10315   if (virtualp
10316       && (current_class_name == NULL_TREE || decl_context != FIELD))
10317     {
10318       error ("virtual outside class declaration");
10319       virtualp = 0;
10320     }
10321
10322   /* Static anonymous unions are dealt with here.  */
10323   if (staticp && decl_context == TYPENAME
10324       && TREE_CODE (declspecs) == TREE_LIST
10325       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
10326     decl_context = FIELD;
10327
10328   /* Warn about storage classes that are invalid for certain
10329      kinds of declarations (parameters, typenames, etc.).  */
10330
10331   if (nclasses > 1)
10332     error ("multiple storage classes in declaration of `%s'", name);
10333   else if (decl_context != NORMAL && nclasses > 0)
10334     {
10335       if ((decl_context == PARM || decl_context == CATCHPARM)
10336           && (RIDBIT_SETP (RID_REGISTER, specbits)
10337               || RIDBIT_SETP (RID_AUTO, specbits)))
10338         ;
10339       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10340         ;
10341       else if (decl_context == FIELD
10342                /* C++ allows static class elements  */
10343                && RIDBIT_SETP (RID_STATIC, specbits))
10344         /* C++ also allows inlines and signed and unsigned elements,
10345            but in those cases we don't come in here.  */
10346         ;
10347       else
10348         {
10349           if (decl_context == FIELD)
10350             {
10351               tree tmp = NULL_TREE;
10352               register int op = 0;
10353
10354               if (declarator)
10355                 {
10356                   /* Avoid trying to get an operand off an identifier node.  */
10357                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10358                     tmp = declarator;
10359                   else
10360                     tmp = TREE_OPERAND (declarator, 0);
10361                   op = IDENTIFIER_OPNAME_P (tmp);
10362                   if (IDENTIFIER_TYPENAME_P (tmp))
10363                     {
10364                       if (IDENTIFIER_GLOBAL_VALUE (tmp)
10365                           && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (tmp))
10366                               == TYPE_DECL))
10367                         name = IDENTIFIER_POINTER (tmp);
10368                       else
10369                         name = "<invalid operator>";
10370                     }
10371                 }
10372               error ("storage class specified for %s `%s'",
10373                      op ? "member operator" : "field",
10374                      name);
10375             }
10376           else
10377             {
10378               if (decl_context == PARM || decl_context == CATCHPARM)
10379                 error ("storage class specified for parameter `%s'", name);
10380               else
10381                 error ("storage class specified for typename");
10382             }
10383           RIDBIT_RESET (RID_REGISTER, specbits);
10384           RIDBIT_RESET (RID_AUTO, specbits);
10385           RIDBIT_RESET (RID_EXTERN, specbits);
10386         }
10387     }
10388   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10389     {
10390       if (toplevel_bindings_p ())
10391         {
10392           /* It's common practice (and completely valid) to have a const
10393              be initialized and declared extern.  */
10394           if (!(type_quals & TYPE_QUAL_CONST))
10395             warning ("`%s' initialized and declared `extern'", name);
10396         }
10397       else
10398         error ("`%s' has both `extern' and initializer", name);
10399     }
10400   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10401            && ! toplevel_bindings_p ())
10402     error ("nested function `%s' declared `extern'", name);
10403   else if (toplevel_bindings_p ())
10404     {
10405       if (RIDBIT_SETP (RID_AUTO, specbits))
10406         error ("top-level declaration of `%s' specifies `auto'", name);
10407     }
10408
10409   if (nclasses > 0 && friendp)
10410     error ("storage class specifiers invalid in friend function declarations");
10411
10412   /* Now figure out the structure of the declarator proper.
10413      Descend through it, creating more complex types, until we reach
10414      the declared identifier (or NULL_TREE, in an absolute declarator).  */
10415
10416   inner_attrs = NULL_TREE;
10417   ignore_attrs = 0;
10418
10419   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10420          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10421     {
10422       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10423          an INDIRECT_REF (for *...),
10424          a CALL_EXPR (for ...(...)),
10425          an identifier (for the name being declared)
10426          or a null pointer (for the place in an absolute declarator
10427          where the name was omitted).
10428          For the last two cases, we have just exited the loop.
10429
10430          For C++ it could also be
10431          a SCOPE_REF (for class :: ...).  In this case, we have converted
10432          sensible names to types, and those are the values we use to
10433          qualify the member name.
10434          an ADDR_EXPR (for &...),
10435          a BIT_NOT_EXPR (for destructors)
10436
10437          At this point, TYPE is the type of elements of an array,
10438          or for a function to return, or for a pointer to point to.
10439          After this sequence of ifs, TYPE is the type of the
10440          array or function or pointer, and DECLARATOR has had its
10441          outermost layer removed.  */
10442
10443       if (type == error_mark_node)
10444         {
10445           if (TREE_CODE (declarator) == SCOPE_REF)
10446             declarator = TREE_OPERAND (declarator, 1);
10447           else
10448             declarator = TREE_OPERAND (declarator, 0);
10449           continue;
10450         }
10451       if (quals != NULL_TREE
10452           && (declarator == NULL_TREE
10453               || TREE_CODE (declarator) != SCOPE_REF))
10454         {
10455           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10456             ctype = TYPE_METHOD_BASETYPE (type);
10457           if (ctype != NULL_TREE)
10458             {
10459               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10460               grok_method_quals (ctype, dummy, quals);
10461               type = TREE_TYPE (dummy);
10462               ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
10463               quals = NULL_TREE;
10464             }
10465         }
10466
10467       /* See the comment for the TREE_LIST case, below.  */
10468       if (ignore_attrs)
10469         ignore_attrs = 0;
10470       else if (inner_attrs)
10471         {
10472           decl_attributes (type, inner_attrs, NULL_TREE);
10473           inner_attrs = NULL_TREE;
10474         }
10475
10476       switch (TREE_CODE (declarator))
10477         {
10478         case TREE_LIST:
10479           {
10480             /* We encode a declarator with embedded attributes using
10481                a TREE_LIST.  The attributes apply to the declarator
10482                directly inside them, so we have to skip an iteration
10483                before applying them to the type.  If the declarator just
10484                inside is the declarator-id, we apply the attrs to the
10485                decl itself.  */
10486             inner_attrs = TREE_PURPOSE (declarator);
10487             ignore_attrs = 1;
10488             declarator = TREE_VALUE (declarator);
10489           }
10490           break;
10491
10492         case ARRAY_REF:
10493           {
10494             register tree size;
10495
10496             size = TREE_OPERAND (declarator, 1);
10497
10498             /* VC++ spells a zero-sized array with [].  */
10499             if (size == NULL_TREE && decl_context == FIELD && ! staticp
10500                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10501               size = integer_zero_node;
10502
10503             declarator = TREE_OPERAND (declarator, 0);
10504
10505             type = create_array_type_for_decl (dname, type, size);
10506
10507             /* VLAs never work as fields. */
10508             if (decl_context == FIELD && !processing_template_decl
10509                 && TREE_CODE (type) == ARRAY_TYPE
10510                 && TYPE_DOMAIN (type) != NULL_TREE
10511                 && !TREE_CONSTANT (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
10512               {
10513                 cp_error ("size of member `%D' is not constant", dname);
10514                 /* Proceed with arbitrary constant size, so that offset
10515                    computations don't get confused. */
10516                 type = create_array_type_for_decl (dname, TREE_TYPE (type),
10517                                                    integer_one_node);
10518               }
10519
10520             ctype = NULL_TREE;
10521           }
10522           break;
10523
10524         case CALL_EXPR:
10525           {
10526             tree arg_types;
10527             int funcdecl_p;
10528             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10529             tree inner_decl = TREE_OPERAND (declarator, 0);
10530
10531             /* Declaring a function type.
10532                Make sure we have a valid type for the function to return.  */
10533
10534             /* We now know that the TYPE_QUALS don't apply to the
10535                decl, but to its return type.  */
10536             type_quals = TYPE_UNQUALIFIED;
10537
10538             /* Warn about some types functions can't return.  */
10539
10540             if (TREE_CODE (type) == FUNCTION_TYPE)
10541               {
10542                 error ("`%s' declared as function returning a function", name);
10543                 type = integer_type_node;
10544               }
10545             if (TREE_CODE (type) == ARRAY_TYPE)
10546               {
10547                 error ("`%s' declared as function returning an array", name);
10548                 type = integer_type_node;
10549               }
10550
10551             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10552               inner_decl = TREE_OPERAND (inner_decl, 1);
10553
10554             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10555               inner_decl = dname;
10556
10557             /* Pick up type qualifiers which should be applied to `this'.  */
10558             quals = CALL_DECLARATOR_QUALS (declarator);
10559
10560             /* Pick up the exception specifications.  */
10561             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10562
10563             /* Say it's a definition only for the CALL_EXPR
10564                closest to the identifier.  */
10565             funcdecl_p
10566               = inner_decl
10567               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10568                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10569                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10570
10571             if (ctype == NULL_TREE
10572                 && decl_context == FIELD
10573                 && funcdecl_p
10574                 && (friendp == 0 || dname == current_class_name))
10575               ctype = current_class_type;
10576
10577             if (ctype && sfk == sfk_conversion)
10578               TYPE_HAS_CONVERSION (ctype) = 1;
10579             if (ctype && constructor_name (ctype) == dname)
10580               {
10581                 /* We are within a class's scope. If our declarator name
10582                    is the same as the class name, and we are defining
10583                    a function, then it is a constructor/destructor, and
10584                    therefore returns a void type.  */
10585
10586                 if (flags == DTOR_FLAG)
10587                   {
10588                     /* ISO C++ 12.4/2.  A destructor may not be
10589                        declared const or volatile.  A destructor may
10590                        not be static.  */
10591                     if (staticp == 2)
10592                       error ("destructor cannot be static member function");
10593                     if (quals)
10594                       {
10595                         cp_error ("destructors may not be `%s'",
10596                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10597                         quals = NULL_TREE;
10598                       }
10599                     if (decl_context == FIELD)
10600                       {
10601                         if (! member_function_or_else (ctype,
10602                                                        current_class_type,
10603                                                        flags))
10604                           return void_type_node;
10605                       }
10606                   }
10607                 else            /* It's a constructor.  */
10608                   {
10609                     if (explicitp == 1)
10610                       explicitp = 2;
10611                     /* ISO C++ 12.1.  A constructor may not be
10612                        declared const or volatile.  A constructor may
10613                        not be virtual.  A constructor may not be
10614                        static.  */
10615                     if (staticp == 2)
10616                       error ("constructor cannot be static member function");
10617                     if (virtualp)
10618                       {
10619                         pedwarn ("constructors cannot be declared virtual");
10620                         virtualp = 0;
10621                       }
10622                     if (quals)
10623                       {
10624                         cp_error ("constructors may not be `%s'",
10625                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10626                         quals = NULL_TREE;
10627                       }
10628                     {
10629                       RID_BIT_TYPE tmp_bits;
10630                       memcpy (&tmp_bits, &specbits, sizeof (RID_BIT_TYPE));
10631                       RIDBIT_RESET (RID_INLINE, tmp_bits);
10632                       RIDBIT_RESET (RID_STATIC, tmp_bits);
10633                       if (RIDBIT_ANY_SET (tmp_bits))
10634                         error ("return value type specifier for constructor ignored");
10635                     }
10636                     if (decl_context == FIELD)
10637                       {
10638                         if (! member_function_or_else (ctype,
10639                                                        current_class_type,
10640                                                        flags))
10641                           return void_type_node;
10642                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10643                         if (sfk != sfk_constructor)
10644                           return NULL_TREE;
10645                       }
10646                   }
10647                 if (decl_context == FIELD)
10648                   staticp = 0;
10649               }
10650             else if (friendp)
10651               {
10652                 if (initialized)
10653                   error ("can't initialize friend function `%s'", name);
10654                 if (virtualp)
10655                   {
10656                     /* Cannot be both friend and virtual.  */
10657                     error ("virtual functions cannot be friends");
10658                     RIDBIT_RESET (RID_FRIEND, specbits);
10659                     friendp = 0;
10660                   }
10661                 if (decl_context == NORMAL)
10662                   error ("friend declaration not in class definition");
10663                 if (current_function_decl && funcdef_flag)
10664                   cp_error ("can't define friend function `%s' in a local class definition",
10665                             name);
10666               }
10667
10668             /* Construct the function type and go to the next
10669                inner layer of declarator.  */
10670
10671             declarator = TREE_OPERAND (declarator, 0);
10672
10673             /* FIXME: This is where default args should be fully
10674                processed.  */
10675
10676             arg_types = grokparms (inner_parms);
10677
10678             if (declarator && flags == DTOR_FLAG)
10679               {
10680                 /* A destructor declared in the body of a class will
10681                    be represented as a BIT_NOT_EXPR.  But, we just
10682                    want the underlying IDENTIFIER.  */
10683                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10684                   declarator = TREE_OPERAND (declarator, 0);
10685
10686                 if (arg_types != void_list_node)
10687                   {
10688                     cp_error ("destructors may not have parameters");
10689                     arg_types = void_list_node;
10690                     last_function_parms = NULL_TREE;
10691                   }
10692               }
10693
10694             /* ANSI says that `const int foo ();'
10695                does not make the function foo const.  */
10696             type = build_function_type (type, arg_types);
10697
10698             {
10699               tree t;
10700               for (t = arg_types; t; t = TREE_CHAIN (t))
10701                 if (TREE_PURPOSE (t)
10702                     && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10703                   {
10704                     add_defarg_fn (type);
10705                     break;
10706                   }
10707             }
10708           }
10709           break;
10710
10711         case ADDR_EXPR:
10712         case INDIRECT_REF:
10713           /* Filter out pointers-to-references and references-to-references.
10714              We can get these if a TYPE_DECL is used.  */
10715
10716           if (TREE_CODE (type) == REFERENCE_TYPE)
10717             {
10718               error ("cannot declare %s to references",
10719                      TREE_CODE (declarator) == ADDR_EXPR
10720                      ? "references" : "pointers");
10721               declarator = TREE_OPERAND (declarator, 0);
10722               continue;
10723             }
10724
10725           if (TREE_CODE (type) == OFFSET_TYPE
10726               && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10727                   || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10728             {
10729               cp_error ("cannot declare pointer to `%#T' member",
10730                         TREE_TYPE (type));
10731               type = TREE_TYPE (type);
10732             }
10733
10734           /* Merge any constancy or volatility into the target type
10735              for the pointer.  */
10736
10737           /* We now know that the TYPE_QUALS don't apply to the decl,
10738              but to the target of the pointer.  */
10739           type_quals = TYPE_UNQUALIFIED;
10740
10741           if (TREE_CODE (declarator) == ADDR_EXPR)
10742             {
10743               if (TREE_CODE (type) == VOID_TYPE)
10744                 error ("invalid type: `void &'");
10745               else
10746                 type = build_reference_type (type);
10747             }
10748           else if (TREE_CODE (type) == METHOD_TYPE)
10749             type = build_ptrmemfunc_type (build_pointer_type (type));
10750           else
10751             type = build_pointer_type (type);
10752
10753           /* Process a list of type modifier keywords (such as
10754              const or volatile) that were given inside the `*' or `&'.  */
10755
10756           if (TREE_TYPE (declarator))
10757             {
10758               register tree typemodlist;
10759               int erred = 0;
10760
10761               constp = 0;
10762               volatilep = 0;
10763               restrictp = 0;
10764               for (typemodlist = TREE_TYPE (declarator); typemodlist;
10765                    typemodlist = TREE_CHAIN (typemodlist))
10766                 {
10767                   tree qualifier = TREE_VALUE (typemodlist);
10768
10769                   if (qualifier == ridpointers[(int) RID_CONST])
10770                     constp++;
10771                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
10772                     volatilep++;
10773                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
10774                     restrictp++;
10775                   else if (!erred)
10776                     {
10777                       erred = 1;
10778                       error ("invalid type modifier within pointer declarator");
10779                     }
10780                 }
10781               if (constp > 1)
10782                 pedwarn ("duplicate `const'");
10783               if (volatilep > 1)
10784                 pedwarn ("duplicate `volatile'");
10785               if (restrictp > 1)
10786                 pedwarn ("duplicate `restrict'");
10787
10788               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10789                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10790                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10791               if (TREE_CODE (declarator) == ADDR_EXPR
10792                   && (constp || volatilep))
10793                 {
10794                   if (constp)
10795                     pedwarn ("discarding `const' applied to a reference");
10796                   if (volatilep)
10797                     pedwarn ("discarding `volatile' applied to a reference");
10798                   type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
10799                 }
10800               type = cp_build_qualified_type (type, type_quals);
10801             }
10802           declarator = TREE_OPERAND (declarator, 0);
10803           ctype = NULL_TREE;
10804           break;
10805
10806         case SCOPE_REF:
10807           {
10808             /* We have converted type names to NULL_TREE if the
10809                name was bogus, or to a _TYPE node, if not.
10810
10811                The variable CTYPE holds the type we will ultimately
10812                resolve to.  The code here just needs to build
10813                up appropriate member types.  */
10814             tree sname = TREE_OPERAND (declarator, 1);
10815             tree t;
10816
10817             /* Destructors can have their visibilities changed as well.  */
10818             if (TREE_CODE (sname) == BIT_NOT_EXPR)
10819               sname = TREE_OPERAND (sname, 0);
10820
10821             if (TREE_COMPLEXITY (declarator) == 0)
10822               /* This needs to be here, in case we are called
10823                  multiple times.  */ ;
10824             else if (TREE_COMPLEXITY (declarator) == -1)
10825               /* Namespace member. */
10826               pop_decl_namespace ();
10827             else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
10828               /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10829             else if (! IS_AGGR_TYPE_CODE
10830                      (TREE_CODE (TREE_OPERAND (declarator, 0))))
10831               ;
10832             else if (TREE_COMPLEXITY (declarator) == current_class_depth)
10833               {
10834                 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10835                    that refer to ctype.  They couldn't be resolved earlier
10836                    because we hadn't pushed into the class yet.
10837                    Example: resolve 'B<T>::type' in
10838                    'B<typename B<T>::type> B<T>::f () { }'.  */
10839                 if (current_template_parms
10840                     && uses_template_parms (type)
10841                     && uses_template_parms (current_class_type))
10842                   {
10843                     tree args = current_template_args ();
10844                     type = tsubst (type, args, /*complain=*/1, NULL_TREE);
10845                   }
10846
10847                 /* This pop_nested_class corresponds to the
10848                    push_nested_class used to push into class scope for
10849                    parsing the argument list of a function decl, in
10850                    qualified_id.  */
10851                 pop_nested_class ();
10852                 TREE_COMPLEXITY (declarator) = current_class_depth;
10853               }
10854             else
10855               my_friendly_abort (16);
10856
10857             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
10858               {
10859                 /* We had a reference to a global decl, or
10860                    perhaps we were given a non-aggregate typedef,
10861                    in which case we cleared this out, and should just
10862                    keep going as though it wasn't there.  */
10863                 declarator = sname;
10864                 continue;
10865               }
10866             ctype = TREE_OPERAND (declarator, 0);
10867
10868             t = ctype;
10869             while (t != NULL_TREE && CLASS_TYPE_P (t))
10870               {
10871                 /* You're supposed to have one `template <...>'
10872                    for every template class, but you don't need one
10873                    for a full specialization.  For example:
10874
10875                      template <class T> struct S{};
10876                      template <> struct S<int> { void f(); };
10877                      void S<int>::f () {}
10878
10879                    is correct; there shouldn't be a `template <>' for
10880                    the definition of `S<int>::f'.  */
10881                 if (CLASSTYPE_TEMPLATE_INFO (t)
10882                     && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
10883                         || uses_template_parms (CLASSTYPE_TI_ARGS (t)))
10884                     && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))
10885                   template_count += 1;
10886
10887                 t = TYPE_MAIN_DECL (t);
10888                 t = DECL_CONTEXT (t);
10889               }
10890
10891             if (sname == NULL_TREE)
10892               goto done_scoping;
10893
10894             if (TREE_CODE (sname) == IDENTIFIER_NODE)
10895               {
10896                 /* This is the `standard' use of the scoping operator:
10897                    basetype :: member .  */
10898
10899                 if (ctype == current_class_type)
10900                   {
10901                     /* class A {
10902                          void A::f ();
10903                        };
10904
10905                        Is this ill-formed?  */
10906
10907                     if (pedantic)
10908                       cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10909                                   ctype, name);
10910                   }
10911                 else if (TREE_CODE (type) == FUNCTION_TYPE)
10912                   {
10913                     if (current_class_type == NULL_TREE || friendp)
10914                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10915                                                       TYPE_ARG_TYPES (type));
10916                     else
10917                       {
10918                         cp_error ("cannot declare member function `%T::%s' within `%T'",
10919                                   ctype, name, current_class_type);
10920                         return void_type_node;
10921                       }
10922                   }
10923                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
10924                          || COMPLETE_TYPE_P (complete_type (ctype)))
10925                   {
10926                     /* Have to move this code elsewhere in this function.
10927                        this code is used for i.e., typedef int A::M; M *pm;
10928
10929                        It is?  How? jason 10/2/94 */
10930
10931                     if (current_class_type)
10932                       {
10933                         cp_error ("cannot declare member `%T::%s' within `%T'",
10934                                   ctype, name, current_class_type);
10935                         return void_type_node;
10936                       }
10937                     type = build_offset_type (ctype, type);
10938                   }
10939                 else
10940                   {
10941                     incomplete_type_error (NULL_TREE, ctype);
10942                     return error_mark_node;
10943                   }
10944
10945                 declarator = sname;
10946               }
10947             else if (TREE_CODE (sname) == SCOPE_REF)
10948               my_friendly_abort (17);
10949             else
10950               {
10951               done_scoping:
10952                 declarator = TREE_OPERAND (declarator, 1);
10953                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
10954                   /* In this case, we will deal with it later.  */
10955                   ;
10956                 else
10957                   {
10958                     if (TREE_CODE (type) == FUNCTION_TYPE)
10959                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10960                                                       TYPE_ARG_TYPES (type));
10961                     else
10962                       type = build_offset_type (ctype, type);
10963                   }
10964               }
10965           }
10966           break;
10967
10968         case BIT_NOT_EXPR:
10969           declarator = TREE_OPERAND (declarator, 0);
10970           break;
10971
10972         case RECORD_TYPE:
10973         case UNION_TYPE:
10974         case ENUMERAL_TYPE:
10975           declarator = NULL_TREE;
10976           break;
10977
10978         case ERROR_MARK:
10979           declarator = NULL_TREE;
10980           break;
10981
10982         default:
10983           my_friendly_abort (158);
10984         }
10985     }
10986
10987   /* See the comment for the TREE_LIST case, above.  */
10988   if (inner_attrs)
10989     {
10990       if (! ignore_attrs)
10991         decl_attributes (type, inner_attrs, NULL_TREE);
10992       else if (attrlist)
10993         TREE_VALUE (attrlist) = chainon (inner_attrs, TREE_VALUE (attrlist));
10994       else
10995         attrlist = build_tree_list (NULL_TREE, inner_attrs);
10996     }
10997
10998   /* Now TYPE has the actual type.  */
10999
11000   if (explicitp == 1 || (explicitp && friendp))
11001     {
11002       /* [dcl.fct.spec] The explicit specifier shall only be used in
11003          declarations of constructors within a class definition.  */
11004       error ("only declarations of constructors can be `explicit'");
11005       explicitp = 0;
11006     }
11007
11008   if (RIDBIT_SETP (RID_MUTABLE, specbits))
11009     {
11010       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
11011         {
11012           error ("non-member `%s' cannot be declared `mutable'", name);
11013           RIDBIT_RESET (RID_MUTABLE, specbits);
11014         }
11015       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
11016         {
11017           error ("non-object member `%s' cannot be declared `mutable'", name);
11018           RIDBIT_RESET (RID_MUTABLE, specbits);
11019         }
11020       else if (TREE_CODE (type) == FUNCTION_TYPE
11021                || TREE_CODE (type) == METHOD_TYPE)
11022         {
11023           error ("function `%s' cannot be declared `mutable'", name);
11024           RIDBIT_RESET (RID_MUTABLE, specbits);
11025         }
11026       else if (staticp)
11027         {
11028           error ("static `%s' cannot be declared `mutable'", name);
11029           RIDBIT_RESET (RID_MUTABLE, specbits);
11030         }
11031       else if (type_quals & TYPE_QUAL_CONST)
11032         {
11033           error ("const `%s' cannot be declared `mutable'", name);
11034           RIDBIT_RESET (RID_MUTABLE, specbits);
11035         }
11036     }
11037
11038   if (declarator == NULL_TREE
11039       || TREE_CODE (declarator) == IDENTIFIER_NODE
11040       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
11041           && (TREE_CODE (type) == FUNCTION_TYPE
11042               || TREE_CODE (type) == METHOD_TYPE)))
11043     /* OK */;
11044   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11045     {
11046       cp_error ("template-id `%D' used as a declarator", declarator);
11047       declarator = dname;
11048     }
11049   else
11050     /* Unexpected declarator format.  */
11051     my_friendly_abort (990210);
11052
11053   /* If this is declaring a typedef name, return a TYPE_DECL.  */
11054
11055   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
11056     {
11057       tree decl;
11058
11059       /* Note that the grammar rejects storage classes
11060          in typenames, fields or parameters.  */
11061       if (current_lang_name == lang_name_java)
11062         TYPE_FOR_JAVA (type) = 1;
11063
11064       if (decl_context == FIELD)
11065         {
11066           if (declarator == constructor_name (current_class_type))
11067             cp_pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
11068                         declarator);
11069           decl = build_lang_decl (TYPE_DECL, declarator, type);
11070         }
11071       else
11072         {
11073           decl = build_decl (TYPE_DECL, declarator, type);
11074           if (!current_function_decl)
11075             DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
11076         }
11077
11078       /* If the user declares "typedef struct {...} foo" then the
11079          struct will have an anonymous name.  Fill that name in now.
11080          Nothing can refer to it, so nothing needs know about the name
11081          change.  */
11082       if (type != error_mark_node
11083           && declarator
11084           && TYPE_NAME (type)
11085           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11086           && TYPE_ANONYMOUS_P (type)
11087           && CP_TYPE_QUALS (type) == TYPE_UNQUALIFIED)
11088         {
11089           tree oldname = TYPE_NAME (type);
11090           tree t;
11091
11092           /* Replace the anonymous name with the real name everywhere.  */
11093           lookup_tag_reverse (type, declarator);
11094           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
11095             if (TYPE_NAME (t) == oldname)
11096               TYPE_NAME (t) = decl;
11097
11098           if (TYPE_LANG_SPECIFIC (type))
11099             TYPE_WAS_ANONYMOUS (type) = 1;
11100
11101           /* If this is a typedef within a template class, the nested
11102              type is a (non-primary) template.  The name for the
11103              template needs updating as well.  */
11104           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
11105             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
11106               = TYPE_IDENTIFIER (type);
11107
11108           /* FIXME remangle member functions; member functions of a
11109              type with external linkage have external linkage.  */
11110         }
11111
11112       if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
11113         {
11114           cp_error_at ("typedef name may not be class-qualified", decl);
11115           return NULL_TREE;
11116         }
11117       else if (quals)
11118         {
11119           if (ctype == NULL_TREE)
11120             {
11121               if (TREE_CODE (type) != METHOD_TYPE)
11122                 cp_error_at ("invalid type qualifier for non-member function type", decl);
11123               else
11124                 ctype = TYPE_METHOD_BASETYPE (type);
11125             }
11126           if (ctype != NULL_TREE)
11127             grok_method_quals (ctype, decl, quals);
11128         }
11129
11130       if (RIDBIT_SETP (RID_SIGNED, specbits)
11131           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
11132         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
11133
11134       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
11135                       inlinep, friendp, raises != NULL_TREE);
11136
11137       if (initialized)
11138         error ("typedef declaration includes an initializer");
11139
11140       return decl;
11141     }
11142
11143   /* Detect the case of an array type of unspecified size
11144      which came, as such, direct from a typedef name.
11145      We must copy the type, so that each identifier gets
11146      a distinct type, so that each identifier's size can be
11147      controlled separately by its own initializer.  */
11148
11149   if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
11150       && TYPE_DOMAIN (type) == NULL_TREE)
11151     {
11152       type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
11153     }
11154
11155   /* Detect where we're using a typedef of function type to declare a
11156      function. last_function_parms will not be set, so we must create
11157      it now.  */
11158
11159   if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE)
11160     {
11161       tree decls = NULL_TREE;
11162       tree args;
11163
11164       for (args = TYPE_ARG_TYPES (type); args; args = TREE_CHAIN (args))
11165         {
11166           tree decl = build_decl (PARM_DECL, NULL_TREE, TREE_VALUE (args));
11167
11168           TREE_CHAIN (decl) = decls;
11169           decls = decl;
11170         }
11171
11172       last_function_parms = nreverse (decls);
11173     }
11174
11175   /* If this is a type name (such as, in a cast or sizeof),
11176      compute the type and return it now.  */
11177
11178   if (decl_context == TYPENAME)
11179     {
11180       /* Note that the grammar rejects storage classes
11181          in typenames, fields or parameters.  */
11182       if (type_quals != TYPE_UNQUALIFIED)
11183         type_quals = TYPE_UNQUALIFIED;
11184
11185       /* Special case: "friend class foo" looks like a TYPENAME context.  */
11186       if (friendp)
11187         {
11188           if (type_quals != TYPE_UNQUALIFIED)
11189             {
11190               cp_error ("type qualifiers specified for friend class declaration");
11191               type_quals = TYPE_UNQUALIFIED;
11192             }
11193           if (inlinep)
11194             {
11195               cp_error ("`inline' specified for friend class declaration");
11196               inlinep = 0;
11197             }
11198
11199           /* Until core issue 180 is resolved, allow 'friend typename A::B'.
11200              But don't allow implicit typenames except with a class-key.  */
11201           if (!current_aggr && (TREE_CODE (type) != TYPENAME_TYPE
11202                                 || IMPLICIT_TYPENAME_P (type)))
11203             {
11204               if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
11205                 cp_pedwarn ("template parameters cannot be friends");
11206               else if (TREE_CODE (type) == TYPENAME_TYPE)
11207                 cp_pedwarn ("\
11208 friend declaration requires class-key, i.e. `friend class %T::%T'",
11209                             constructor_name (current_class_type),
11210                             TYPE_IDENTIFIER (type));
11211               else
11212                 cp_pedwarn ("\
11213 friend declaration requires class-key, i.e. `friend %#T'",
11214                             type);
11215             }
11216
11217           /* Only try to do this stuff if we didn't already give up.  */
11218           if (type != integer_type_node)
11219             {
11220               decl_type_access_control (TYPE_NAME (type));
11221
11222               /* A friendly class?  */
11223               if (current_class_type)
11224                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
11225               else
11226                 cp_error ("trying to make class `%T' a friend of global scope",
11227                           type);
11228
11229               type = void_type_node;
11230             }
11231         }
11232       else if (quals)
11233         {
11234           if (ctype == NULL_TREE)
11235             {
11236               if (TREE_CODE (type) != METHOD_TYPE)
11237                 cp_error ("invalid qualifiers on non-member function type");
11238               else
11239                 ctype = TYPE_METHOD_BASETYPE (type);
11240             }
11241           if (ctype)
11242             {
11243               tree dummy = build_decl (TYPE_DECL, declarator, type);
11244               grok_method_quals (ctype, dummy, quals);
11245               type = TREE_TYPE (dummy);
11246             }
11247         }
11248
11249       return type;
11250     }
11251   else if (declarator == NULL_TREE && decl_context != PARM
11252            && decl_context != CATCHPARM
11253            && TREE_CODE (type) != UNION_TYPE
11254            && ! bitfield)
11255     {
11256       cp_error ("abstract declarator `%T' used as declaration", type);
11257       declarator = make_anon_name ();
11258     }
11259
11260   /* `void' at top level (not within pointer)
11261      is allowed only in typedefs or type names.
11262      We don't complain about parms either, but that is because
11263      a better error message can be made later.  */
11264
11265   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
11266     {
11267       if (! declarator)
11268         error ("unnamed variable or field declared void");
11269       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
11270         {
11271           if (IDENTIFIER_OPNAME_P (declarator))
11272             my_friendly_abort (356);
11273           else
11274             error ("variable or field `%s' declared void", name);
11275         }
11276       else
11277         error ("variable or field declared void");
11278       type = integer_type_node;
11279     }
11280
11281   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11282      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
11283
11284   if (decl_context == PARM || decl_context == CATCHPARM)
11285     {
11286       if (ctype || in_namespace)
11287         error ("cannot use `::' in parameter declaration");
11288
11289       /* A parameter declared as an array of T is really a pointer to T.
11290          One declared as a function is really a pointer to a function.
11291          One declared as a member is really a pointer to member.  */
11292
11293       if (TREE_CODE (type) == ARRAY_TYPE)
11294         {
11295           /* Transfer const-ness of array into that of type pointed to.  */
11296           type = build_pointer_type (TREE_TYPE (type));
11297           type_quals = TYPE_UNQUALIFIED;
11298         }
11299       else if (TREE_CODE (type) == FUNCTION_TYPE)
11300         type = build_pointer_type (type);
11301       else if (TREE_CODE (type) == OFFSET_TYPE)
11302         type = build_pointer_type (type);
11303     }
11304
11305   {
11306     register tree decl;
11307
11308     if (decl_context == PARM)
11309       {
11310         decl = build_decl (PARM_DECL, declarator, type);
11311
11312         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
11313                         inlinep, friendp, raises != NULL_TREE);
11314
11315         /* Compute the type actually passed in the parmlist,
11316            for the case where there is no prototype.
11317            (For example, shorts and chars are passed as ints.)
11318            When there is a prototype, this is overridden later.  */
11319
11320         DECL_ARG_TYPE (decl) = type_promotes_to (type);
11321       }
11322     else if (decl_context == FIELD)
11323       {
11324         if (type == error_mark_node)
11325           {
11326             /* Happens when declaring arrays of sizes which
11327                are error_mark_node, for example.  */
11328             decl = NULL_TREE;
11329           }
11330         else if (in_namespace && !friendp)
11331           {
11332             /* Something like struct S { int N::j; };  */
11333             cp_error ("invalid use of `::'");
11334             decl = NULL_TREE;
11335           }
11336         else if (TREE_CODE (type) == FUNCTION_TYPE)
11337           {
11338             int publicp = 0;
11339             tree function_context;
11340
11341             /* We catch the others as conflicts with the builtin
11342                typedefs.  */
11343             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11344               {
11345                 cp_error ("function `%D' cannot be declared friend",
11346                           declarator);
11347                 friendp = 0;
11348               }
11349
11350             if (friendp == 0)
11351               {
11352                 if (ctype == NULL_TREE)
11353                   ctype = current_class_type;
11354
11355                 if (ctype == NULL_TREE)
11356                   {
11357                     cp_error ("can't make `%D' into a method -- not in a class",
11358                               declarator);
11359                     return void_type_node;
11360                   }
11361
11362                 /* ``A union may [ ... ] not [ have ] virtual functions.''
11363                    ARM 9.5 */
11364                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11365                   {
11366                     cp_error ("function `%D' declared virtual inside a union",
11367                               declarator);
11368                     return void_type_node;
11369                   }
11370
11371                 if (declarator == ansi_opname (NEW_EXPR)
11372                     || declarator == ansi_opname (VEC_NEW_EXPR)
11373                     || declarator == ansi_opname (DELETE_EXPR)
11374                     || declarator == ansi_opname (VEC_DELETE_EXPR))
11375                   {
11376                     if (virtualp)
11377                       {
11378                         cp_error ("`%D' cannot be declared virtual, since it is always static",
11379                                   declarator);
11380                         virtualp = 0;
11381                       }
11382                   }
11383                 else if (staticp < 2)
11384                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11385                                                   TYPE_ARG_TYPES (type));
11386               }
11387
11388             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
11389             function_context = (ctype != NULL_TREE) ?
11390               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11391             publicp = (! friendp || ! staticp)
11392               && function_context == NULL_TREE;
11393             decl = grokfndecl (ctype, type,
11394                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11395                                ? declarator : dname,
11396                                declarator,
11397                                virtualp, flags, quals, raises,
11398                                friendp ? -1 : 0, friendp, publicp, inlinep,
11399                                funcdef_flag, template_count, in_namespace);
11400             if (decl == NULL_TREE)
11401               return decl;
11402 #if 0
11403             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
11404             /* The decl and setting of decl_machine_attr is also turned off.  */
11405             decl = build_decl_attribute_variant (decl, decl_machine_attr);
11406 #endif
11407
11408             /* [class.conv.ctor]
11409
11410                A constructor declared without the function-specifier
11411                explicit that can be called with a single parameter
11412                specifies a conversion from the type of its first
11413                parameter to the type of its class.  Such a constructor
11414                is called a converting constructor.  */
11415             if (explicitp == 2)
11416               DECL_NONCONVERTING_P (decl) = 1;
11417             else if (DECL_CONSTRUCTOR_P (decl))
11418               {
11419                 /* The constructor can be called with exactly one
11420                    parameter if there is at least one parameter, and
11421                    any subsequent parameters have default arguments.
11422                    Ignore any compiler-added parms.  */
11423                 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (decl);
11424
11425                 if (arg_types == void_list_node
11426                     || (arg_types
11427                         && TREE_CHAIN (arg_types)
11428                         && TREE_CHAIN (arg_types) != void_list_node
11429                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11430                   DECL_NONCONVERTING_P (decl) = 1;
11431               }
11432           }
11433         else if (TREE_CODE (type) == METHOD_TYPE)
11434           {
11435             /* We only get here for friend declarations of
11436                members of other classes.  */
11437             /* All method decls are public, so tell grokfndecl to set
11438                TREE_PUBLIC, also.  */
11439             decl = grokfndecl (ctype, type, declarator, declarator,
11440                                virtualp, flags, quals, raises,
11441                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11442                                template_count, in_namespace);
11443             if (decl == NULL_TREE)
11444               return NULL_TREE;
11445           }
11446         else if (!staticp && ! processing_template_decl
11447                  && !COMPLETE_TYPE_P (complete_type (type))
11448                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11449           {
11450             if (declarator)
11451               cp_error ("field `%D' has incomplete type", declarator);
11452             else
11453               cp_error ("name `%T' has incomplete type", type);
11454
11455             /* If we're instantiating a template, tell them which
11456                instantiation made the field's type be incomplete.  */
11457             if (current_class_type
11458                 && TYPE_NAME (current_class_type)
11459                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11460                 && declspecs && TREE_VALUE (declspecs)
11461                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11462               cp_error ("  in instantiation of template `%T'",
11463                         current_class_type);
11464
11465             type = error_mark_node;
11466             decl = NULL_TREE;
11467           }
11468         else
11469           {
11470             if (friendp)
11471               {
11472                 error ("`%s' is neither function nor member function; cannot be declared friend",
11473                        IDENTIFIER_POINTER (declarator));
11474                 friendp = 0;
11475               }
11476             decl = NULL_TREE;
11477           }
11478
11479         if (friendp)
11480           {
11481             /* Friends are treated specially.  */
11482             if (ctype == current_class_type)
11483               warning ("member functions are implicitly friends of their class");
11484             else
11485               {
11486                 tree t = NULL_TREE;
11487                 if (decl && DECL_NAME (decl))
11488                   {
11489                     if (template_class_depth (current_class_type) == 0)
11490                       {
11491                         decl
11492                           = check_explicit_specialization
11493                           (declarator, decl,
11494                            template_count, 2 * (funcdef_flag != 0) + 4);
11495                         if (decl == error_mark_node)
11496                           return error_mark_node;
11497                       }
11498
11499                     t = do_friend (ctype, declarator, decl,
11500                                    last_function_parms, attrlist, flags, quals,
11501                                    funcdef_flag);
11502                   }
11503                 if (t && funcdef_flag)
11504                   return t;
11505
11506                 return void_type_node;
11507               }
11508           }
11509
11510         /* Structure field.  It may not be a function, except for C++ */
11511
11512         if (decl == NULL_TREE)
11513           {
11514             if (initialized)
11515               {
11516                 if (!staticp)
11517                   {
11518                     /* An attempt is being made to initialize a non-static
11519                        member.  But, from [class.mem]:
11520
11521                        4 A member-declarator can contain a
11522                        constant-initializer only if it declares a static
11523                        member (_class.static_) of integral or enumeration
11524                        type, see _class.static.data_.
11525
11526                        This used to be relatively common practice, but
11527                        the rest of the compiler does not correctly
11528                        handle the initialization unless the member is
11529                        static so we make it static below.  */
11530                     cp_pedwarn ("ISO C++ forbids initialization of member `%D'",
11531                                 declarator);
11532                     cp_pedwarn ("making `%D' static", declarator);
11533                     staticp = 1;
11534                   }
11535
11536                 if (uses_template_parms (type))
11537                   /* We'll check at instantiation time.  */
11538                   ;
11539                 else if (check_static_variable_definition (declarator,
11540                                                            type))
11541                   /* If we just return the declaration, crashes
11542                      will sometimes occur.  We therefore return
11543                      void_type_node, as if this was a friend
11544                      declaration, to cause callers to completely
11545                      ignore this declaration.  */
11546                   return void_type_node;
11547               }
11548
11549             /* 9.2p13 [class.mem] */
11550             if (declarator == constructor_name (current_class_type)
11551                 /* The standard does not allow non-static data members
11552                    here either, but we agreed at the 10/99 meeting
11553                    to change that in TC 1 so that they are allowed in
11554                    classes with no user-defined constructors.  */
11555                 && staticp)
11556               cp_pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
11557                           declarator);
11558
11559             if (staticp)
11560               {
11561                 /* C++ allows static class members.  All other work
11562                    for this is done by grokfield.  */
11563                 decl = build_lang_decl (VAR_DECL, declarator, type);
11564                 TREE_STATIC (decl) = 1;
11565                 /* In class context, 'static' means public access.  */
11566                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11567               }
11568             else
11569               {
11570                 decl = build_decl (FIELD_DECL, declarator, type);
11571                 DECL_NONADDRESSABLE_P (decl) = bitfield;
11572                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11573                   {
11574                     DECL_MUTABLE_P (decl) = 1;
11575                     RIDBIT_RESET (RID_MUTABLE, specbits);
11576                   }
11577               }
11578
11579             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11580                             inlinep, friendp, raises != NULL_TREE);
11581           }
11582       }
11583     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11584       {
11585         tree original_name;
11586         int publicp = 0;
11587
11588         if (! declarator)
11589           return NULL_TREE;
11590
11591         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11592           original_name = dname;
11593         else
11594           original_name = declarator;
11595
11596         if (RIDBIT_SETP (RID_AUTO, specbits))
11597           error ("storage class `auto' invalid for function `%s'", name);
11598         else if (RIDBIT_SETP (RID_REGISTER, specbits))
11599           error ("storage class `register' invalid for function `%s'", name);
11600
11601         /* Function declaration not at top level.
11602            Storage classes other than `extern' are not allowed
11603            and `extern' makes no difference.  */
11604         if (! toplevel_bindings_p ()
11605             && (RIDBIT_SETP (RID_STATIC, specbits)
11606                 || RIDBIT_SETP (RID_INLINE, specbits))
11607             && pedantic)
11608           {
11609             if (RIDBIT_SETP (RID_STATIC, specbits))
11610               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11611             else
11612               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11613           }
11614
11615         if (ctype == NULL_TREE)
11616           {
11617             if (virtualp)
11618               {
11619                 error ("virtual non-class function `%s'", name);
11620                 virtualp = 0;
11621               }
11622           }
11623         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11624           type = build_cplus_method_type (ctype, TREE_TYPE (type),
11625                                           TYPE_ARG_TYPES (type));
11626
11627         /* Record presence of `static'.  */
11628         publicp = (ctype != NULL_TREE
11629                    || RIDBIT_SETP (RID_EXTERN, specbits)
11630                    || !RIDBIT_SETP (RID_STATIC, specbits));
11631
11632         decl = grokfndecl (ctype, type, original_name, declarator,
11633                            virtualp, flags, quals, raises,
11634                            1, friendp,
11635                            publicp, inlinep, funcdef_flag,
11636                            template_count, in_namespace);
11637         if (decl == NULL_TREE)
11638           return NULL_TREE;
11639
11640         if (staticp == 1)
11641           {
11642             int illegal_static = 0;
11643
11644             /* Don't allow a static member function in a class, and forbid
11645                declaring main to be static.  */
11646             if (TREE_CODE (type) == METHOD_TYPE)
11647               {
11648                 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11649                 illegal_static = 1;
11650               }
11651             else if (current_function_decl)
11652               {
11653                 /* FIXME need arm citation */
11654                 error ("cannot declare static function inside another function");
11655                 illegal_static = 1;
11656               }
11657
11658             if (illegal_static)
11659               {
11660                 staticp = 0;
11661                 RIDBIT_RESET (RID_STATIC, specbits);
11662               }
11663           }
11664       }
11665     else
11666       {
11667         /* It's a variable.  */
11668
11669         /* An uninitialized decl with `extern' is a reference.  */
11670         decl = grokvardecl (type, declarator, &specbits,
11671                             initialized,
11672                             (type_quals & TYPE_QUAL_CONST) != 0,
11673                             in_namespace);
11674         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11675                         inlinep, friendp, raises != NULL_TREE);
11676
11677         if (ctype)
11678           {
11679             DECL_CONTEXT (decl) = ctype;
11680             if (staticp == 1)
11681               {
11682                 cp_pedwarn ("static member `%D' re-declared as static", decl);
11683                 staticp = 0;
11684                 RIDBIT_RESET (RID_STATIC, specbits);
11685               }
11686             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11687               {
11688                 cp_error ("static member `%D' declared `register'", decl);
11689                 RIDBIT_RESET (RID_REGISTER, specbits);
11690               }
11691             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11692               {
11693                 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11694                             decl);
11695                 RIDBIT_RESET (RID_EXTERN, specbits);
11696               }
11697           }
11698       }
11699
11700     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11701
11702     /* Record `register' declaration for warnings on &
11703        and in case doing stupid register allocation.  */
11704
11705     if (RIDBIT_SETP (RID_REGISTER, specbits))
11706       DECL_REGISTER (decl) = 1;
11707
11708     if (RIDBIT_SETP (RID_EXTERN, specbits))
11709       DECL_THIS_EXTERN (decl) = 1;
11710
11711     if (RIDBIT_SETP (RID_STATIC, specbits))
11712       DECL_THIS_STATIC (decl) = 1;
11713
11714     /* Record constancy and volatility.  There's no need to do this
11715        when processing a template; we'll do this for the instantiated
11716        declaration based on the type of DECL.  */
11717     if (!processing_template_decl)
11718       c_apply_type_quals_to_decl (type_quals, decl);
11719
11720     return decl;
11721   }
11722 }
11723 \f
11724 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11725    An empty exprlist is a parmlist.  An exprlist which
11726    contains only identifiers at the global level
11727    is a parmlist.  Otherwise, it is an exprlist.  */
11728
11729 int
11730 parmlist_is_exprlist (exprs)
11731      tree exprs;
11732 {
11733   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11734     return 0;
11735
11736   if (toplevel_bindings_p ())
11737     {
11738       /* At the global level, if these are all identifiers,
11739          then it is a parmlist.  */
11740       while (exprs)
11741         {
11742           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11743             return 1;
11744           exprs = TREE_CHAIN (exprs);
11745         }
11746       return 0;
11747     }
11748   return 1;
11749 }
11750
11751 /* Subroutine of start_function.  Ensure that each of the parameter
11752    types (as listed in PARMS) is complete, as is required for a
11753    function definition.  */
11754
11755 static void
11756 require_complete_types_for_parms (parms)
11757      tree parms;
11758 {
11759   for (; parms; parms = TREE_CHAIN (parms))
11760     {
11761       if (VOID_TYPE_P (TREE_TYPE (parms)))
11762         /* grokparms will have already issued an error */
11763         TREE_TYPE (parms) = error_mark_node;
11764       else if (complete_type_or_else (TREE_TYPE (parms), parms))
11765         layout_decl (parms, 0);
11766       else
11767         TREE_TYPE (parms) = error_mark_node;
11768     }
11769 }
11770
11771 /* Returns non-zero if T is a local variable.  */
11772
11773 int
11774 local_variable_p (t)
11775      tree t;
11776 {
11777   if ((TREE_CODE (t) == VAR_DECL
11778        /* A VAR_DECL with a context that is a _TYPE is a static data
11779           member.  */
11780        && !TYPE_P (CP_DECL_CONTEXT (t))
11781        /* Any other non-local variable must be at namespace scope.  */
11782        && !DECL_NAMESPACE_SCOPE_P (t))
11783       || (TREE_CODE (t) == PARM_DECL))
11784     return 1;
11785
11786   return 0;
11787 }
11788
11789 /* Returns non-zero if T is an automatic local variable or a label.
11790    (These are the declarations that need to be remapped when the code
11791    containing them is duplicated.)  */
11792
11793 int
11794 nonstatic_local_decl_p (t)
11795      tree t;
11796 {
11797   return ((local_variable_p (t) && !TREE_STATIC (t))
11798           || TREE_CODE (t) == LABEL_DECL
11799           || TREE_CODE (t) == RESULT_DECL);
11800 }
11801
11802 /* Like local_variable_p, but suitable for use as a tree-walking
11803    function.  */
11804
11805 static tree
11806 local_variable_p_walkfn (tp, walk_subtrees, data)
11807      tree *tp;
11808      int *walk_subtrees ATTRIBUTE_UNUSED;
11809      void *data ATTRIBUTE_UNUSED;
11810 {
11811   return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
11812           ? *tp : NULL_TREE);
11813 }
11814
11815 /* Check that ARG, which is a default-argument expression for a
11816    parameter DECL, is legal.  Returns ARG, or ERROR_MARK_NODE, if
11817    something goes wrong.  DECL may also be a _TYPE node, rather than a
11818    DECL, if there is no DECL available.  */
11819
11820 tree
11821 check_default_argument (decl, arg)
11822      tree decl;
11823      tree arg;
11824 {
11825   tree var;
11826   tree decl_type;
11827
11828   if (TREE_CODE (arg) == DEFAULT_ARG)
11829     /* We get a DEFAULT_ARG when looking at an in-class declaration
11830        with a default argument.  Ignore the argument for now; we'll
11831        deal with it after the class is complete.  */
11832     return arg;
11833
11834   if (processing_template_decl || uses_template_parms (arg))
11835     /* We don't do anything checking until instantiation-time.  Note
11836        that there may be uninstantiated arguments even for an
11837        instantiated function, since default arguments are not
11838        instantiated until they are needed.  */
11839     return arg;
11840
11841   if (TYPE_P (decl))
11842     {
11843       decl_type = decl;
11844       decl = NULL_TREE;
11845     }
11846   else
11847     decl_type = TREE_TYPE (decl);
11848
11849   if (arg == error_mark_node
11850       || decl == error_mark_node
11851       || TREE_TYPE (arg) == error_mark_node
11852       || decl_type == error_mark_node)
11853     /* Something already went wrong.  There's no need to check
11854        further.  */
11855     return error_mark_node;
11856
11857   /* [dcl.fct.default]
11858
11859      A default argument expression is implicitly converted to the
11860      parameter type.  */
11861   if (!TREE_TYPE (arg)
11862       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
11863     {
11864       if (decl)
11865         cp_error ("default argument for `%#D' has type `%T'",
11866                   decl, TREE_TYPE (arg));
11867       else
11868         cp_error ("default argument for parameter of type `%T' has type `%T'",
11869                   decl_type, TREE_TYPE (arg));
11870
11871       return error_mark_node;
11872     }
11873
11874   /* [dcl.fct.default]
11875
11876      Local variables shall not be used in default argument
11877      expressions.
11878
11879      The keyword `this' shall not be used in a default argument of a
11880      member function.  */
11881   var = walk_tree_without_duplicates (&arg, local_variable_p_walkfn,
11882                                       NULL);
11883   if (var)
11884     {
11885       cp_error ("default argument `%E' uses local variable `%D'",
11886                 arg, var);
11887       return error_mark_node;
11888     }
11889
11890   /* All is well.  */
11891   return arg;
11892 }
11893
11894 /* Decode the list of parameter types for a function type.
11895    Given the list of things declared inside the parens,
11896    return a list of types.
11897
11898    We determine whether ellipsis parms are used by PARMLIST_ELLIPSIS_P
11899    flag. If unset, we append void_list_node. A parmlist declared
11900    as `(void)' is accepted as the empty parmlist.
11901
11902    Also set last_function_parms to the chain of PARM_DECLs.  */
11903
11904 static tree
11905 grokparms (first_parm)
11906      tree first_parm;
11907 {
11908   tree result = NULL_TREE;
11909   tree decls = NULL_TREE;
11910   int ellipsis = !first_parm || PARMLIST_ELLIPSIS_P (first_parm);
11911   tree parm, chain;
11912   int any_error = 0;
11913
11914   my_friendly_assert (!first_parm || TREE_PARMLIST (first_parm), 20001115);
11915
11916   for (parm = first_parm; parm != NULL_TREE; parm = chain)
11917     {
11918       tree type = NULL_TREE;
11919       register tree decl = TREE_VALUE (parm);
11920       tree init = TREE_PURPOSE (parm);
11921
11922       chain = TREE_CHAIN (parm);
11923       /* @@ weak defense against parse errors.  */
11924       if (TREE_CODE (decl) != VOID_TYPE
11925           && TREE_CODE (decl) != TREE_LIST)
11926         {
11927           /* Give various messages as the need arises.  */
11928           if (TREE_CODE (decl) == STRING_CST)
11929             cp_error ("invalid string constant `%E'", decl);
11930           else if (TREE_CODE (decl) == INTEGER_CST)
11931             error ("invalid integer constant in parameter list, did you forget to give parameter name?");
11932           continue;
11933         }
11934
11935       if (parm == void_list_node)
11936         break;
11937
11938       decl = grokdeclarator (TREE_VALUE (decl), TREE_PURPOSE (decl),
11939                      PARM, init != NULL_TREE, NULL_TREE);
11940       if (! decl || TREE_TYPE (decl) == error_mark_node)
11941         continue;
11942
11943       type = TREE_TYPE (decl);
11944       if (VOID_TYPE_P (type))
11945         {
11946           if (same_type_p (type, void_type_node)
11947               && !DECL_NAME (decl) && !result && !chain && !ellipsis)
11948             /* this is a parmlist of `(void)', which is ok.  */
11949             break;
11950           incomplete_type_error (decl, type);
11951           /* It's not a good idea to actually create parameters of
11952              type `void'; other parts of the compiler assume that a
11953              void type terminates the parameter list.  */
11954           type = error_mark_node;
11955           TREE_TYPE (decl) = error_mark_node;
11956         }
11957
11958       if (type != error_mark_node)
11959         {
11960           /* Top-level qualifiers on the parameters are
11961              ignored for function types.  */
11962           type = TYPE_MAIN_VARIANT (type);
11963           if (TREE_CODE (type) == METHOD_TYPE)
11964             {
11965               cp_error ("parameter `%D' invalidly declared method type", decl);
11966               type = build_pointer_type (type);
11967               TREE_TYPE (decl) = type;
11968             }
11969           else if (TREE_CODE (type) == OFFSET_TYPE)
11970             {
11971               cp_error ("parameter `%D' invalidly declared offset type", decl);
11972               type = build_pointer_type (type);
11973               TREE_TYPE (decl) = type;
11974             }
11975           else if (abstract_virtuals_error (decl, type))
11976             any_error = 1;  /* Seems like a good idea. */
11977           else if (POINTER_TYPE_P (type))
11978             {
11979               /* [dcl.fct]/6, parameter types cannot contain pointers
11980                  (references) to arrays of unknown bound.  */
11981               tree t = TREE_TYPE (type);
11982               int ptr = TYPE_PTR_P (type);
11983
11984               while (1)
11985                 {
11986                   if (TYPE_PTR_P (t))
11987                     ptr = 1;
11988                   else if (TREE_CODE (t) != ARRAY_TYPE)
11989                     break;
11990                   else if (!TYPE_DOMAIN (t))
11991                     break;
11992                   t = TREE_TYPE (t);
11993                 }
11994               if (TREE_CODE (t) == ARRAY_TYPE)
11995                 cp_error ("parameter `%D' includes %s to array of unknown bound `%T'",
11996                           decl, ptr ? "pointer" : "reference", t);
11997             }
11998
11999           DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
12000           if (PROMOTE_PROTOTYPES
12001               && INTEGRAL_TYPE_P (type)
12002               && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
12003             DECL_ARG_TYPE (decl) = integer_type_node;
12004           if (!any_error && init)
12005             init = check_default_argument (decl, init);
12006           else
12007             init = NULL_TREE;
12008         }
12009
12010       TREE_CHAIN (decl) = decls;
12011       decls = decl;
12012       result = tree_cons (init, type, result);
12013     }
12014   decls = nreverse (decls);
12015   result = nreverse (result);
12016   if (!ellipsis)
12017     result = chainon (result, void_list_node);
12018   last_function_parms = decls;
12019
12020   return result;
12021 }
12022
12023 \f
12024 /* D is a constructor or overloaded `operator='.  Returns non-zero if
12025    D's arguments allow it to be a copy constructor, or copy assignment
12026    operator.  */
12027
12028 int
12029 copy_args_p (d)
12030      tree d;
12031 {
12032   tree t;
12033
12034   if (!DECL_FUNCTION_MEMBER_P (d))
12035     return 0;
12036
12037   t = FUNCTION_FIRST_USER_PARMTYPE (d);
12038   if (t && TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
12039       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t)))
12040           == DECL_CONTEXT (d))
12041       && (TREE_CHAIN (t) == NULL_TREE
12042           || TREE_CHAIN (t) == void_list_node
12043           || TREE_PURPOSE (TREE_CHAIN (t))))
12044     return 1;
12045   return 0;
12046 }
12047
12048 /* These memoizing functions keep track of special properties which
12049    a class may have.  `grok_ctor_properties' notices whether a class
12050    has a constructor of the form X(X&), and also complains
12051    if the class has a constructor of the form X(X).
12052    `grok_op_properties' takes notice of the various forms of
12053    operator= which are defined, as well as what sorts of type conversion
12054    may apply.  Both functions take a FUNCTION_DECL as an argument.  */
12055
12056 int
12057 grok_ctor_properties (ctype, decl)
12058      tree ctype, decl;
12059 {
12060   tree parmtypes = FUNCTION_FIRST_USER_PARMTYPE (decl);
12061   tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
12062
12063   /* [class.copy]
12064
12065      A non-template constructor for class X is a copy constructor if
12066      its first parameter is of type X&, const X&, volatile X& or const
12067      volatile X&, and either there are no other parameters or else all
12068      other parameters have default arguments.  */
12069   if (TREE_CODE (parmtype) == REFERENCE_TYPE
12070       && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype
12071       && sufficient_parms_p (TREE_CHAIN (parmtypes))
12072       && !(DECL_TEMPLATE_INSTANTIATION (decl)
12073            && is_member_template (DECL_TI_TEMPLATE (decl))))
12074     {
12075       TYPE_HAS_INIT_REF (ctype) = 1;
12076       if (CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12077         TYPE_HAS_CONST_INIT_REF (ctype) = 1;
12078     }
12079   /* [class.copy]
12080
12081      A declaration of a constructor for a class X is ill-formed if its
12082      first parameter is of type (optionally cv-qualified) X and either
12083      there are no other parameters or else all other parameters have
12084      default arguments.
12085
12086      We *don't* complain about member template instantiations that
12087      have this form, though; they can occur as we try to decide what
12088      constructor to use during overload resolution.  Since overload
12089      resolution will never prefer such a constructor to the
12090      non-template copy constructor (which is either explicitly or
12091      implicitly defined), there's no need to worry about their
12092      existence.  Theoretically, they should never even be
12093      instantiated, but that's hard to forestall.  */
12094   else if (TYPE_MAIN_VARIANT (parmtype) == ctype
12095            && sufficient_parms_p (TREE_CHAIN (parmtypes))
12096            && !(DECL_TEMPLATE_INSTANTIATION (decl)
12097                 && is_member_template (DECL_TI_TEMPLATE (decl))))
12098     {
12099       cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
12100                 ctype, ctype);
12101       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
12102       return 0;
12103     }
12104   else if (TREE_CODE (parmtype) == VOID_TYPE
12105            || TREE_PURPOSE (parmtypes) != NULL_TREE)
12106     TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
12107
12108   return 1;
12109 }
12110
12111 /* An operator with this code is unary, but can also be binary.  */
12112
12113 static int
12114 ambi_op_p (code)
12115      enum tree_code code;
12116 {
12117   return (code == INDIRECT_REF
12118           || code == ADDR_EXPR
12119           || code == CONVERT_EXPR
12120           || code == NEGATE_EXPR
12121           || code == PREINCREMENT_EXPR
12122           || code == PREDECREMENT_EXPR);
12123 }
12124
12125 /* An operator with this name can only be unary.  */
12126
12127 static int
12128 unary_op_p (code)
12129      enum tree_code code;
12130 {
12131   return (code == TRUTH_NOT_EXPR
12132           || code == BIT_NOT_EXPR
12133           || code == COMPONENT_REF
12134           || code == TYPE_EXPR);
12135 }
12136
12137 /* Do a little sanity-checking on how they declared their operator.  */
12138
12139 void
12140 grok_op_properties (decl, virtualp, friendp)
12141      tree decl;
12142      int virtualp, friendp;
12143 {
12144   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
12145   tree argtype;
12146   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
12147   tree name = DECL_NAME (decl);
12148   enum tree_code operator_code;
12149   int arity;
12150
12151   /* Count the number of arguments.  */
12152   for (argtype = argtypes, arity = 0;
12153        argtype && argtype != void_list_node;
12154        argtype = TREE_CHAIN (argtype))
12155     ++arity;
12156
12157   if (current_class_type == NULL_TREE)
12158     friendp = 1;
12159
12160   if (DECL_CONV_FN_P (decl))
12161     operator_code = TYPE_EXPR;
12162   else
12163     do
12164       {
12165 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P)       \
12166         if (ansi_opname (CODE) == name)                         \
12167           {                                                     \
12168             operator_code = CODE;                               \
12169             break;                                              \
12170           }                                                     \
12171         else if (ansi_assopname (CODE) == name)                 \
12172           {                                                     \
12173             operator_code = CODE;                               \
12174             DECL_ASSIGNMENT_OPERATOR_P (decl) = 1;              \
12175             break;                                              \
12176           }
12177
12178 #include "operators.def"
12179 #undef DEF_OPERATOR
12180
12181         my_friendly_abort (20000527);
12182       }
12183     while (0);
12184   my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526);
12185   SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12186
12187   if (! friendp)
12188     {
12189       switch (operator_code)
12190         {
12191         case CALL_EXPR:
12192           TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
12193           break;
12194
12195         case ARRAY_REF:
12196           TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
12197           break;
12198
12199         case COMPONENT_REF:
12200         case MEMBER_REF:
12201           TYPE_OVERLOADS_ARROW (current_class_type) = 1;
12202           break;
12203
12204         case NEW_EXPR:
12205           TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
12206           break;
12207
12208         case DELETE_EXPR:
12209           TYPE_GETS_DELETE (current_class_type) |= 1;
12210           break;
12211
12212         case VEC_NEW_EXPR:
12213           TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
12214           break;
12215
12216         case VEC_DELETE_EXPR:
12217           TYPE_GETS_DELETE (current_class_type) |= 2;
12218           break;
12219
12220         default:
12221           break;
12222         }
12223     }
12224
12225   if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
12226     {
12227       /* When the compiler encounters the definition of A::operator new, it
12228          doesn't look at the class declaration to find out if it's static.  */
12229       if (methodp)
12230         revert_static_member_fn (decl);
12231
12232       TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12233     }
12234   else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
12235     {
12236       if (methodp)
12237         revert_static_member_fn (decl);
12238
12239       TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12240     }
12241   else
12242     {
12243       /* An operator function must either be a non-static member function
12244          or have at least one parameter of a class, a reference to a class,
12245          an enumeration, or a reference to an enumeration.  13.4.0.6 */
12246       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12247         {
12248           if (operator_code == TYPE_EXPR
12249               || operator_code == CALL_EXPR
12250               || operator_code == COMPONENT_REF
12251               || operator_code == ARRAY_REF
12252               || operator_code == NOP_EXPR)
12253             cp_error ("`%D' must be a nonstatic member function", decl);
12254           else
12255             {
12256               tree p = argtypes;
12257
12258               if (DECL_STATIC_FUNCTION_P (decl))
12259                 cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
12260
12261               if (p)
12262                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12263                   {
12264                     tree arg = TREE_VALUE (p);
12265                     if (TREE_CODE (arg) == REFERENCE_TYPE)
12266                       arg = TREE_TYPE (arg);
12267
12268                     /* This lets bad template code slip through.  */
12269                     if (IS_AGGR_TYPE (arg)
12270                         || TREE_CODE (arg) == ENUMERAL_TYPE
12271                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12272                         || TREE_CODE (arg) == BOUND_TEMPLATE_TEMPLATE_PARM)
12273                       goto foundaggr;
12274                   }
12275               cp_error
12276                 ("`%D' must have an argument of class or enumerated type",
12277                  decl);
12278             foundaggr:
12279               ;
12280             }
12281         }
12282
12283       if (operator_code == CALL_EXPR)
12284         return;                 /* No restrictions on args. */
12285
12286       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12287         {
12288           tree t = TREE_TYPE (name);
12289           if (! friendp)
12290             {
12291               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12292               const char *what = 0;
12293
12294               if (ref)
12295                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12296
12297               if (TREE_CODE (t) == VOID_TYPE)
12298                 what = "void";
12299               else if (t == current_class_type)
12300                 what = "the same type";
12301               /* Don't force t to be complete here.  */
12302               else if (IS_AGGR_TYPE (t)
12303                        && COMPLETE_TYPE_P (t)
12304                        && DERIVED_FROM_P (t, current_class_type))
12305                 what = "a base class";
12306
12307               if (what)
12308                 warning ("conversion to %s%s will never use a type conversion operator",
12309                          ref ? "a reference to " : "", what);
12310             }
12311         }
12312
12313       if (DECL_ASSIGNMENT_OPERATOR_P (decl)
12314           && operator_code == NOP_EXPR)
12315         {
12316           tree parmtype;
12317
12318           if (arity != 2 && methodp)
12319             {
12320               cp_error ("`%D' must take exactly one argument", decl);
12321               return;
12322             }
12323           parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
12324
12325           /* [class.copy]
12326
12327              A user-declared copy assignment operator X::operator= is
12328              a non-static non-template member function of class X with
12329              exactly one parameter of type X, X&, const X&, volatile
12330              X& or const volatile X&.  */
12331           if (copy_assignment_arg_p (parmtype, virtualp)
12332               && !(DECL_TEMPLATE_INSTANTIATION (decl)
12333                    && is_member_template (DECL_TI_TEMPLATE (decl)))
12334               && ! friendp)
12335             {
12336               TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
12337               if (TREE_CODE (parmtype) != REFERENCE_TYPE
12338                   || CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12339                 TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
12340             }
12341         }
12342       else if (operator_code == COND_EXPR)
12343         {
12344           /* 13.4.0.3 */
12345           cp_error ("ISO C++ prohibits overloading operator ?:");
12346         }
12347       else if (ambi_op_p (operator_code))
12348         {
12349           if (arity == 1)
12350             /* We pick the one-argument operator codes by default, so
12351                we don't have to change anything.  */
12352             ;
12353           else if (arity == 2)
12354             {
12355               /* If we thought this was a unary operator, we now know
12356                  it to be a binary operator.  */
12357               switch (operator_code)
12358                 {
12359                 case INDIRECT_REF:
12360                   operator_code = MULT_EXPR;
12361                   break;
12362
12363                 case ADDR_EXPR:
12364                   operator_code = BIT_AND_EXPR;
12365                   break;
12366
12367                 case CONVERT_EXPR:
12368                   operator_code = PLUS_EXPR;
12369                   break;
12370
12371                 case NEGATE_EXPR:
12372                   operator_code = MINUS_EXPR;
12373                   break;
12374
12375                 case PREINCREMENT_EXPR:
12376                   operator_code = POSTINCREMENT_EXPR;
12377                   break;
12378
12379                 case PREDECREMENT_EXPR:
12380                   operator_code = POSTDECREMENT_EXPR;
12381                   break;
12382
12383                 default:
12384                   my_friendly_abort (20000527);
12385                 }
12386
12387               SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12388
12389               if ((operator_code == POSTINCREMENT_EXPR
12390                    || operator_code == POSTDECREMENT_EXPR)
12391                   && ! processing_template_decl
12392                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12393                 {
12394                   if (methodp)
12395                     cp_error ("postfix `%D' must take `int' as its argument",
12396                               decl);
12397                   else
12398                     cp_error
12399                       ("postfix `%D' must take `int' as its second argument",
12400                        decl);
12401                 }
12402             }
12403           else
12404             {
12405               if (methodp)
12406                 cp_error ("`%D' must take either zero or one argument", decl);
12407               else
12408                 cp_error ("`%D' must take either one or two arguments", decl);
12409             }
12410
12411           /* More Effective C++ rule 6.  */
12412           if (warn_ecpp
12413               && (operator_code == POSTINCREMENT_EXPR
12414                   || operator_code == POSTDECREMENT_EXPR
12415                   || operator_code == PREINCREMENT_EXPR
12416                   || operator_code == PREDECREMENT_EXPR))
12417             {
12418               tree arg = TREE_VALUE (argtypes);
12419               tree ret = TREE_TYPE (TREE_TYPE (decl));
12420               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12421                 arg = TREE_TYPE (arg);
12422               arg = TYPE_MAIN_VARIANT (arg);
12423               if (operator_code == PREINCREMENT_EXPR
12424                   || operator_code == PREDECREMENT_EXPR)
12425                 {
12426                   if (TREE_CODE (ret) != REFERENCE_TYPE
12427                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12428                                        arg))
12429                     cp_warning ("prefix `%D' should return `%T'", decl,
12430                                 build_reference_type (arg));
12431                 }
12432               else
12433                 {
12434                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12435                     cp_warning ("postfix `%D' should return `%T'", decl, arg);
12436                 }
12437             }
12438         }
12439       else if (unary_op_p (operator_code))
12440         {
12441           if (arity != 1)
12442             {
12443               if (methodp)
12444                 cp_error ("`%D' must take `void'", decl);
12445               else
12446                 cp_error ("`%D' must take exactly one argument", decl);
12447             }
12448         }
12449       else /* if (binary_op_p (operator_code)) */
12450         {
12451           if (arity != 2)
12452             {
12453               if (methodp)
12454                 cp_error ("`%D' must take exactly one argument", decl);
12455               else
12456                 cp_error ("`%D' must take exactly two arguments", decl);
12457             }
12458
12459           /* More Effective C++ rule 7.  */
12460           if (warn_ecpp
12461               && (operator_code == TRUTH_ANDIF_EXPR
12462                   || operator_code == TRUTH_ORIF_EXPR
12463                   || operator_code == COMPOUND_EXPR))
12464             cp_warning ("user-defined `%D' always evaluates both arguments",
12465                         decl);
12466         }
12467
12468       /* Effective C++ rule 23.  */
12469       if (warn_ecpp
12470           && arity == 2
12471           && (operator_code == PLUS_EXPR
12472               || operator_code == MINUS_EXPR
12473               || operator_code == TRUNC_DIV_EXPR
12474               || operator_code == MULT_EXPR)
12475           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12476         cp_warning ("`%D' should return by value", decl);
12477
12478       /* 13.4.0.8 */
12479       for (; argtypes && argtypes != void_list_node;
12480           argtypes = TREE_CHAIN (argtypes))
12481         if (TREE_PURPOSE (argtypes))
12482           {
12483             TREE_PURPOSE (argtypes) = NULL_TREE;
12484             if (operator_code == POSTINCREMENT_EXPR
12485                 || operator_code == POSTDECREMENT_EXPR)
12486               {
12487                 if (pedantic)
12488                   cp_pedwarn ("`%D' cannot have default arguments", decl);
12489               }
12490             else
12491               cp_error ("`%D' cannot have default arguments", decl);
12492           }
12493
12494     }
12495 }
12496 \f
12497 static const char *
12498 tag_name (code)
12499      enum tag_types code;
12500 {
12501   switch (code)
12502     {
12503     case record_type:
12504       return "struct";
12505     case class_type:
12506       return "class";
12507     case union_type:
12508       return "union ";
12509     case enum_type:
12510       return "enum";
12511     default:
12512       my_friendly_abort (981122);
12513     }
12514 }
12515
12516 /* Get the struct, enum or union (CODE says which) with tag NAME.
12517    Define the tag as a forward-reference if it is not defined.
12518
12519    C++: If a class derivation is given, process it here, and report
12520    an error if multiple derivation declarations are not identical.
12521
12522    If this is a definition, come in through xref_tag and only look in
12523    the current frame for the name (since C++ allows new names in any
12524    scope.)  */
12525
12526 tree
12527 xref_tag (code_type_node, name, globalize)
12528      tree code_type_node;
12529      tree name;
12530      int globalize;
12531 {
12532   enum tag_types tag_code;
12533   enum tree_code code;
12534   register tree ref, t;
12535   struct binding_level *b = current_binding_level;
12536   int got_type = 0;
12537   tree attributes = NULL_TREE;
12538   tree context = NULL_TREE;
12539
12540   /* If we are called from the parser, code_type_node will sometimes be a
12541      TREE_LIST.  This indicates that the user wrote
12542      "class __attribute__ ((foo)) bar".  Extract the attributes so we can
12543      use them later.  */
12544   if (TREE_CODE (code_type_node) == TREE_LIST)
12545     {
12546       attributes = TREE_PURPOSE (code_type_node);
12547       code_type_node = TREE_VALUE (code_type_node);
12548     }
12549
12550   tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12551   switch (tag_code)
12552     {
12553     case record_type:
12554     case class_type:
12555       code = RECORD_TYPE;
12556       break;
12557     case union_type:
12558       code = UNION_TYPE;
12559       break;
12560     case enum_type:
12561       code = ENUMERAL_TYPE;
12562       break;
12563     default:
12564       my_friendly_abort (18);
12565     }
12566
12567   /* If a cross reference is requested, look up the type
12568      already defined for this tag and return it.  */
12569   if (TYPE_P (name))
12570     {
12571       t = name;
12572       name = TYPE_IDENTIFIER (t);
12573       got_type = 1;
12574     }
12575   else
12576     t = IDENTIFIER_TYPE_VALUE (name);
12577
12578   /* Warn about 'friend struct Inherited;' doing the wrong thing.  */
12579   if (t && globalize && TREE_CODE (t) == TYPENAME_TYPE)
12580     {
12581       static int explained;
12582
12583       cp_warning ("`%s %T' declares a new type at namespace scope;\n\
12584 to refer to the inherited type, say `%s %T::%T'%s",
12585                   tag_name (tag_code), name, tag_name (tag_code),
12586                   constructor_name (current_class_type), TYPE_IDENTIFIER (t),
12587                   (!explained ? "\n\
12588 (names from dependent base classes are not visible to unqualified name lookup)"
12589                    : ""));
12590
12591       explained = 1;
12592     }
12593
12594   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12595       && TREE_CODE (t) != BOUND_TEMPLATE_TEMPLATE_PARM)
12596     t = NULL_TREE;
12597
12598   if (! globalize)
12599     {
12600       /* If we know we are defining this tag, only look it up in
12601          this scope and don't try to find it as a type.  */
12602       ref = lookup_tag (code, name, b, 1);
12603     }
12604   else
12605     {
12606       if (t)
12607         {
12608           /* [dcl.type.elab] If the identifier resolves to a
12609              typedef-name or a template type-parameter, the
12610              elaborated-type-specifier is ill-formed.  */
12611           if (t != TYPE_MAIN_VARIANT (t)
12612               || (CLASS_TYPE_P (t) && TYPE_WAS_ANONYMOUS (t)))
12613             cp_pedwarn ("using typedef-name `%D' after `%s'",
12614                         TYPE_NAME (t), tag_name (tag_code));
12615           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12616             cp_error ("using template type parameter `%T' after `%s'",
12617                       t, tag_name (tag_code));
12618
12619           ref = t;
12620         }
12621       else
12622         ref = lookup_tag (code, name, b, 0);
12623
12624       if (! ref)
12625         {
12626           /* Try finding it as a type declaration.  If that wins,
12627              use it.  */
12628           ref = lookup_name (name, 1);
12629
12630           if (ref != NULL_TREE
12631               && processing_template_decl
12632               && DECL_CLASS_TEMPLATE_P (ref)
12633               && template_class_depth (current_class_type) == 0)
12634             /* Since GLOBALIZE is true, we're declaring a global
12635                template, so we want this type.  */
12636             ref = DECL_TEMPLATE_RESULT (ref);
12637
12638           if (ref && TREE_CODE (ref) == TYPE_DECL
12639               && TREE_CODE (TREE_TYPE (ref)) == code)
12640             ref = TREE_TYPE (ref);
12641           else
12642             ref = NULL_TREE;
12643         }
12644
12645       if (ref && current_class_type
12646           && template_class_depth (current_class_type)
12647           && PROCESSING_REAL_TEMPLATE_DECL_P ())
12648         {
12649           /* Since GLOBALIZE is non-zero, we are not looking at a
12650              definition of this tag.  Since, in addition, we are currently
12651              processing a (member) template declaration of a template
12652              class, we must be very careful; consider:
12653
12654                template <class X>
12655                struct S1
12656
12657                template <class U>
12658                struct S2
12659                { template <class V>
12660                friend struct S1; };
12661
12662              Here, the S2::S1 declaration should not be confused with the
12663              outer declaration.  In particular, the inner version should
12664              have a template parameter of level 2, not level 1.  This
12665              would be particularly important if the member declaration
12666              were instead:
12667
12668                template <class V = U> friend struct S1;
12669
12670              say, when we should tsubst into `U' when instantiating
12671              S2.  On the other hand, when presented with:
12672
12673                  template <class T>
12674                  struct S1 {
12675                    template <class U>
12676                    struct S2 {};
12677                    template <class U>
12678                    friend struct S2;
12679                  };
12680
12681               we must find the inner binding eventually.  We
12682               accomplish this by making sure that the new type we
12683               create to represent this declaration has the right
12684               TYPE_CONTEXT.  */
12685           context = TYPE_CONTEXT (ref);
12686           ref = NULL_TREE;
12687         }
12688     }
12689
12690   if (! ref)
12691     {
12692       /* If no such tag is yet defined, create a forward-reference node
12693          and record it as the "definition".
12694          When a real declaration of this type is found,
12695          the forward-reference will be altered into a real type.  */
12696       if (code == ENUMERAL_TYPE)
12697         {
12698           cp_error ("use of enum `%#D' without previous declaration", name);
12699
12700           ref = make_node (ENUMERAL_TYPE);
12701
12702           /* Give the type a default layout like unsigned int
12703              to avoid crashing if it does not get defined.  */
12704           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12705           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12706           TYPE_USER_ALIGN (ref) = 0;
12707           TREE_UNSIGNED (ref) = 1;
12708           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12709           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12710           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12711
12712           /* Enable us to recognize when a type is created in class context.
12713              To do nested classes correctly, this should probably be cleared
12714              out when we leave this classes scope.  Currently this in only
12715              done in `start_enum'.  */
12716
12717           pushtag (name, ref, globalize);
12718         }
12719       else
12720         {
12721           struct binding_level *old_b = class_binding_level;
12722
12723           ref = make_aggr_type (code);
12724           TYPE_CONTEXT (ref) = context;
12725
12726 #ifdef NONNESTED_CLASSES
12727           /* Class types don't nest the way enums do.  */
12728           class_binding_level = (struct binding_level *)0;
12729 #endif
12730           pushtag (name, ref, globalize);
12731           class_binding_level = old_b;
12732         }
12733     }
12734   else
12735     {
12736       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12737         redeclare_class_template (ref, current_template_parms);
12738     }
12739
12740   /* Until the type is defined, tentatively accept whatever
12741      structure tag the user hands us.  */
12742   if (!COMPLETE_TYPE_P (ref)
12743       && ref != current_class_type
12744       /* Have to check this, in case we have contradictory tag info.  */
12745       && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
12746     {
12747       if (tag_code == class_type)
12748         CLASSTYPE_DECLARED_CLASS (ref) = 1;
12749       else if (tag_code == record_type)
12750         CLASSTYPE_DECLARED_CLASS (ref) = 0;
12751     }
12752
12753   TREE_TYPE (ref) = attributes;
12754
12755   return ref;
12756 }
12757
12758 tree
12759 xref_tag_from_type (old, id, globalize)
12760      tree old, id;
12761      int globalize;
12762 {
12763   tree code_type_node;
12764
12765   if (TREE_CODE (old) == RECORD_TYPE)
12766     code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
12767                       ? class_type_node : record_type_node);
12768   else
12769     code_type_node = union_type_node;
12770
12771   if (id == NULL_TREE)
12772     id = TYPE_IDENTIFIER (old);
12773
12774   return xref_tag (code_type_node, id, globalize);
12775 }
12776
12777 /* REF is a type (named NAME), for which we have just seen some
12778    baseclasses.  BINFO is a list of those baseclasses; the
12779    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12780    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
12781    struct, or union.  */
12782
12783 void
12784 xref_basetypes (code_type_node, name, ref, binfo)
12785      tree code_type_node;
12786      tree name, ref;
12787      tree binfo;
12788 {
12789   /* In the declaration `A : X, Y, ... Z' we mark all the types
12790      (A, X, Y, ..., Z) so we can check for duplicates.  */
12791   tree binfos;
12792   tree base;
12793
12794   int i, len;
12795   enum tag_types tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12796
12797   if (tag_code == union_type)
12798     {
12799       cp_error ("derived union `%T' invalid", ref);
12800       return;
12801     }
12802
12803   len = list_length (binfo);
12804
12805   /* First, make sure that any templates in base-classes are
12806      instantiated.  This ensures that if we call ourselves recursively
12807      we do not get confused about which classes are marked and which
12808      are not.  */
12809   for (base = binfo; base; base = TREE_CHAIN (base))
12810     complete_type (TREE_VALUE (base));
12811
12812   SET_CLASSTYPE_MARKED (ref);
12813   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
12814
12815   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
12816     {
12817       /* The base of a derived struct is public by default.  */
12818       int via_public
12819         = (TREE_PURPOSE (binfo) == access_public_node
12820            || TREE_PURPOSE (binfo) == access_public_virtual_node
12821            || (tag_code != class_type
12822                && (TREE_PURPOSE (binfo) == access_default_node
12823                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
12824       int via_protected
12825         = (TREE_PURPOSE (binfo) == access_protected_node
12826            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
12827       int via_virtual
12828         = (TREE_PURPOSE (binfo) == access_private_virtual_node
12829            || TREE_PURPOSE (binfo) == access_protected_virtual_node
12830            || TREE_PURPOSE (binfo) == access_public_virtual_node
12831            || TREE_PURPOSE (binfo) == access_default_virtual_node);
12832       tree basetype = TREE_VALUE (binfo);
12833       tree base_binfo;
12834
12835       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
12836         basetype = TREE_TYPE (basetype);
12837       if (!basetype
12838           || (TREE_CODE (basetype) != RECORD_TYPE
12839               && TREE_CODE (basetype) != TYPENAME_TYPE
12840               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
12841               && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM))
12842         {
12843           cp_error ("base type `%T' fails to be a struct or class type",
12844                     TREE_VALUE (binfo));
12845           continue;
12846         }
12847
12848       GNU_xref_hier (name, basetype, via_public, via_virtual, 0);
12849
12850       /* This code replaces similar code in layout_basetypes.
12851          We put the complete_type first for implicit `typename'.  */
12852       if (!COMPLETE_TYPE_P (basetype)
12853           && ! (current_template_parms && uses_template_parms (basetype)))
12854         {
12855           cp_error ("base class `%T' has incomplete type", basetype);
12856           continue;
12857         }
12858       else
12859         {
12860           if (CLASSTYPE_MARKED (basetype))
12861             {
12862               if (basetype == ref)
12863                 cp_error ("recursive type `%T' undefined", basetype);
12864               else
12865                 cp_error ("duplicate base type `%T' invalid", basetype);
12866               continue;
12867             }
12868
12869           if (TYPE_FOR_JAVA (basetype)
12870               && (current_lang_stack
12871                   == &VARRAY_TREE (current_lang_base, 0)))
12872             TYPE_FOR_JAVA (ref) = 1;
12873
12874           /* Note that the BINFO records which describe individual
12875              inheritances are *not* shared in the lattice!  They
12876              cannot be shared because a given baseclass may be
12877              inherited with different `accessibility' by different
12878              derived classes.  (Each BINFO record describing an
12879              individual inheritance contains flags which say what
12880              the `accessibility' of that particular inheritance is.)  */
12881
12882           base_binfo
12883             = make_binfo (size_zero_node, basetype,
12884                           CLASS_TYPE_P (basetype)
12885                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
12886                           CLASS_TYPE_P (basetype)
12887                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
12888
12889           TREE_VEC_ELT (binfos, i) = base_binfo;
12890           TREE_VIA_PUBLIC (base_binfo) = via_public;
12891           TREE_VIA_PROTECTED (base_binfo) = via_protected;
12892           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
12893           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
12894
12895           /* We need to unshare the binfos now so that lookups during class
12896              definition work.  */
12897           unshare_base_binfos (base_binfo);
12898
12899           SET_CLASSTYPE_MARKED (basetype);
12900
12901           /* We are free to modify these bits because they are meaningless
12902              at top level, and BASETYPE is a top-level type.  */
12903           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
12904             {
12905               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
12906               /* Converting to a virtual base class requires looking
12907                  up the offset of the virtual base.  */
12908               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12909             }
12910
12911           if (CLASS_TYPE_P (basetype))
12912             {
12913               TYPE_HAS_NEW_OPERATOR (ref)
12914                 |= TYPE_HAS_NEW_OPERATOR (basetype);
12915               TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
12916                 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
12917               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
12918               /* If the base-class uses multiple inheritance, so do we.  */
12919               TYPE_USES_MULTIPLE_INHERITANCE (ref)
12920                 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
12921               /* Likewise, if converting to a base of the base may require
12922                  code, then we may need to generate code to convert to a
12923                  base as well.  */
12924               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
12925                 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
12926             }
12927
12928           i += 1;
12929         }
12930     }
12931   if (i)
12932     TREE_VEC_LENGTH (binfos) = i;
12933   else
12934     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
12935
12936   if (i > 1)
12937     {
12938       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
12939       /* If there is more than one non-empty they cannot be at the same
12940          address.  */
12941       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12942     }
12943
12944   /* Unmark all the types.  */
12945   while (--i >= 0)
12946     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
12947   CLEAR_CLASSTYPE_MARKED (ref);
12948
12949   /* Now that we know all the base-classes, set up the list of virtual
12950      bases.  */
12951   get_vbase_types (ref);
12952 }
12953
12954 \f
12955 /* Begin compiling the definition of an enumeration type.
12956    NAME is its name (or null if anonymous).
12957    Returns the type object, as yet incomplete.
12958    Also records info about it so that build_enumerator
12959    may be used to declare the individual values as they are read.  */
12960
12961 tree
12962 start_enum (name)
12963      tree name;
12964 {
12965   register tree enumtype = NULL_TREE;
12966   struct binding_level *b = current_binding_level;
12967
12968   /* If this is the real definition for a previous forward reference,
12969      fill in the contents in the same object that used to be the
12970      forward reference.  */
12971
12972   if (name != NULL_TREE)
12973     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
12974
12975   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
12976     {
12977       cp_error ("multiple definition of `%#T'", enumtype);
12978       cp_error_at ("previous definition here", enumtype);
12979       /* Clear out TYPE_VALUES, and start again.  */
12980       TYPE_VALUES (enumtype) = NULL_TREE;
12981     }
12982   else
12983     {
12984       enumtype = make_node (ENUMERAL_TYPE);
12985       pushtag (name, enumtype, 0);
12986     }
12987
12988   if (current_class_type)
12989     TREE_ADDRESSABLE (b->tags) = 1;
12990
12991   GNU_xref_decl (current_function_decl, enumtype);
12992   return enumtype;
12993 }
12994
12995 /* After processing and defining all the values of an enumeration type,
12996    install their decls in the enumeration type and finish it off.
12997    ENUMTYPE is the type object and VALUES a list of name-value pairs.  */
12998
12999 void
13000 finish_enum (enumtype)
13001      tree enumtype;
13002 {
13003   tree pair;
13004   tree minnode;
13005   tree maxnode;
13006   tree t;
13007   bool unsignedp;
13008   int lowprec;
13009   int highprec;
13010   int precision;
13011
13012   /* We built up the VALUES in reverse order.  */
13013   TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
13014
13015   /* [dcl.enum]
13016
13017      Following the closing brace of an enum-specifier, each
13018      enumerator has the type of its enumeration.  Prior to the
13019      closing brace, the type of each enumerator is the type of
13020      its initializing value.  */
13021   for (pair = TYPE_VALUES (enumtype); pair; pair = TREE_CHAIN (pair))
13022     TREE_TYPE (TREE_VALUE (pair)) = enumtype;
13023
13024   /* For a enum defined in a template, all further processing is
13025      postponed until the template is instantiated.  */
13026   if (processing_template_decl)
13027     {
13028       tree scope = current_scope ();
13029       if (scope && TREE_CODE (scope) == FUNCTION_DECL)
13030         add_stmt (build_min (TAG_DEFN, enumtype));
13031
13032       return;
13033     }
13034
13035   /* Figure out what the minimum and maximum values of the enumerators
13036      are.  */
13037   if (TYPE_VALUES (enumtype))
13038     {
13039       minnode = maxnode = NULL_TREE;
13040
13041       for (pair = TYPE_VALUES (enumtype);
13042            pair;
13043            pair = TREE_CHAIN (pair))
13044         {
13045           tree value;
13046
13047           value = DECL_INITIAL (TREE_VALUE (pair));
13048
13049           if (!minnode)
13050             minnode = maxnode = value;
13051           else if (tree_int_cst_lt (maxnode, value))
13052             maxnode = value;
13053           else if (tree_int_cst_lt (value, minnode))
13054             minnode = value;
13055         }
13056     }
13057   else
13058     minnode = maxnode = integer_zero_node;
13059
13060   /* Compute the number of bits require to represent all values of the
13061      enumeration.  We must do this before the type of MINNODE and
13062      MAXNODE are transformed, since min_precision relies on the
13063      TREE_TYPE of the value it is passed.  */
13064   unsignedp = tree_int_cst_sgn (minnode) >= 0;
13065   lowprec = min_precision (minnode, unsignedp);
13066   highprec = min_precision (maxnode, unsignedp);
13067   precision = MAX (lowprec, highprec);
13068
13069   /* Set the TREE_TYPE for the values as well.  That's so that when we
13070      call decl_constant_value we get an entity of the right type (but
13071      with the constant value).  In addition, transform the TYPE_VALUES
13072      list to contain the values, rather than the CONST_DECLs for them.  */
13073   for (pair = TYPE_VALUES (enumtype); pair; pair = TREE_CHAIN (pair))
13074     {
13075       tree value = DECL_INITIAL (TREE_VALUE (pair));
13076
13077       TREE_TYPE (value) = enumtype;
13078       TREE_VALUE (pair) = value;
13079     }
13080
13081   /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
13082   TYPE_SIZE (enumtype) = NULL_TREE;
13083   TYPE_PRECISION (enumtype) = precision;
13084   if (unsignedp)
13085     fixup_unsigned_type (enumtype);
13086   else
13087     fixup_signed_type (enumtype);
13088
13089   if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
13090     /* Use the width of the narrowest normal C type which is wide
13091        enough.  */
13092     TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
13093                                                 (precision, 1));
13094   else
13095     TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
13096
13097   TYPE_SIZE (enumtype) = NULL_TREE;
13098   layout_type (enumtype);
13099
13100   /* Fix up all variant types of this enum type.  */
13101   for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
13102     {
13103       TYPE_VALUES (t) = TYPE_VALUES (enumtype);
13104       TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (enumtype);
13105       TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype);
13106       TYPE_SIZE (t) = TYPE_SIZE (enumtype);
13107       TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype);
13108       TYPE_MODE (t) = TYPE_MODE (enumtype);
13109       TYPE_PRECISION (t) = TYPE_PRECISION (enumtype);
13110       TYPE_ALIGN (t) = TYPE_ALIGN (enumtype);
13111       TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype);
13112       TREE_UNSIGNED (t) = TREE_UNSIGNED (enumtype);
13113     }
13114
13115   /* Finish debugging output for this type.  */
13116   rest_of_type_compilation (enumtype, namespace_bindings_p ());
13117 }
13118
13119 /* Build and install a CONST_DECL for an enumeration constant of the
13120    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13121    Assignment of sequential values by default is handled here.  */
13122
13123 void
13124 build_enumerator (name, value, enumtype)
13125      tree name;
13126      tree value;
13127      tree enumtype;
13128 {
13129   tree decl;
13130   tree context;
13131   tree type;
13132   tree values;
13133
13134   /* Remove no-op casts from the value.  */
13135   if (value)
13136     STRIP_TYPE_NOPS (value);
13137
13138   if (! processing_template_decl)
13139     {
13140       /* Validate and default VALUE.  */
13141       if (value != NULL_TREE)
13142         {
13143           value = decl_constant_value (value);
13144
13145           if (TREE_CODE (value) == INTEGER_CST)
13146             {
13147               value = default_conversion (value);
13148               constant_expression_warning (value);
13149             }
13150           else
13151             {
13152               cp_error ("enumerator value for `%D' not integer constant", name);
13153               value = NULL_TREE;
13154             }
13155         }
13156
13157       /* Default based on previous value.  */
13158       if (value == NULL_TREE && ! processing_template_decl)
13159         {
13160           tree prev_value;
13161
13162           if (TYPE_VALUES (enumtype))
13163             {
13164               /* The next value is the previous value ... */
13165               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
13166               /* ... plus one.  */
13167               value = cp_build_binary_op (PLUS_EXPR,
13168                                           prev_value,
13169                                           integer_one_node);
13170
13171               if (tree_int_cst_lt (value, prev_value))
13172                 cp_error ("overflow in enumeration values at `%D'", name);
13173             }
13174           else
13175             value = integer_zero_node;
13176         }
13177
13178       /* Remove no-op casts from the value.  */
13179       if (value)
13180         STRIP_TYPE_NOPS (value);
13181 #if 0
13182       /* To fix MAX_VAL enum consts. (bkoz)  */
13183       TREE_TYPE (value) = integer_type_node;
13184 #endif
13185     }
13186
13187   /* We always have to copy here; not all INTEGER_CSTs are unshared.
13188      Even in other cases, we will later (in finish_enum) be setting
13189      the type of VALUE.  But, we don't need to make a copy if this
13190      VALUE is one of the enumeration constants for this same
13191      enumeration type.  */
13192   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
13193     if (TREE_VALUE (values) == value)
13194       break;
13195   /* If we didn't break out of the loop, then we do need a copy.  */
13196   if (!values && value)
13197     value = copy_node (value);
13198
13199   /* C++ associates enums with global, function, or class declarations.  */
13200   context = current_scope ();
13201
13202   /* Build the actual enumeration constant.  Note that the enumeration
13203     constants have the type of their initializers until the
13204     enumeration is complete:
13205
13206       [ dcl.enum ]
13207
13208       Following the closing brace of an enum-specifier, each enumer-
13209       ator has the type of its enumeration.  Prior to the closing
13210       brace, the type of each enumerator is the type of its
13211       initializing value.
13212
13213     In finish_enum we will reset the type.  Of course, if we're
13214     processing a template, there may be no value.   */
13215   type = value ? TREE_TYPE (value) : NULL_TREE;
13216
13217   if (context && context == current_class_type)
13218     /* This enum declaration is local to the class.  We need the full
13219        lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
13220     decl = build_lang_decl (CONST_DECL, name, type);
13221   else
13222     /* It's a global enum, or it's local to a function.  (Note local to
13223       a function could mean local to a class method.  */
13224     decl = build_decl (CONST_DECL, name, type);
13225
13226   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
13227   DECL_INITIAL (decl) = value;
13228   TREE_READONLY (decl) = 1;
13229
13230   if (context && context == current_class_type)
13231     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13232       on the TYPE_FIELDS list for `S'.  (That's so that you can say
13233       things like `S::i' later.)  */
13234     finish_member_declaration (decl);
13235   else
13236     {
13237       pushdecl (decl);
13238       GNU_xref_decl (current_function_decl, decl);
13239     }
13240
13241   /* Add this enumeration constant to the list for this type.  */
13242   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13243 }
13244
13245 \f
13246 /* We're defining DECL.  Make sure that it's type is OK.  */
13247
13248 static void
13249 check_function_type (decl, current_function_parms)
13250      tree decl;
13251      tree current_function_parms;
13252 {
13253   tree fntype = TREE_TYPE (decl);
13254   tree return_type = complete_type (TREE_TYPE (fntype));
13255
13256   /* In a function definition, arg types must be complete.  */
13257   require_complete_types_for_parms (current_function_parms);
13258
13259   if (!COMPLETE_OR_VOID_TYPE_P (return_type))
13260     {
13261       cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
13262
13263       /* Make it return void instead, but don't change the
13264          type of the DECL_RESULT, in case we have a named return value.  */
13265       if (TREE_CODE (fntype) == METHOD_TYPE)
13266         {
13267           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
13268           TREE_TYPE (decl)
13269             = build_cplus_method_type (ctype,
13270                                        void_type_node,
13271                                        FUNCTION_ARG_CHAIN (decl));
13272         }
13273       else
13274         TREE_TYPE (decl)
13275           = build_function_type (void_type_node,
13276                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
13277       TREE_TYPE (decl)
13278         = build_exception_variant (fntype,
13279                                    TYPE_RAISES_EXCEPTIONS (fntype));
13280     }
13281   else
13282     abstract_virtuals_error (decl, TREE_TYPE (fntype));
13283 }
13284
13285 /* Create the FUNCTION_DECL for a function definition.
13286    DECLSPECS and DECLARATOR are the parts of the declaration;
13287    they describe the function's name and the type it returns,
13288    but twisted together in a fashion that parallels the syntax of C.
13289
13290    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13291    DECLARATOR is really the DECL for the function we are about to
13292    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13293    indicating that the function is an inline defined in-class.
13294
13295    This function creates a binding context for the function body
13296    as well as setting up the FUNCTION_DECL in current_function_decl.
13297
13298    Returns 1 on success.  If the DECLARATOR is not suitable for a function
13299    (it defines a datum instead), we return 0, which tells
13300    yyparse to report a parse error.
13301
13302    For C++, we must first check whether that datum makes any sense.
13303    For example, "class A local_a(1,2);" means that variable local_a
13304    is an aggregate of type A, which should have a constructor
13305    applied to it with the argument list [1, 2].  */
13306
13307 int
13308 start_function (declspecs, declarator, attrs, flags)
13309      tree declspecs, declarator, attrs;
13310      int flags;
13311 {
13312   tree decl1;
13313   tree ctype = NULL_TREE;
13314   tree fntype;
13315   tree restype;
13316   extern int have_extern_spec;
13317   extern int used_extern_spec;
13318   int doing_friend = 0;
13319   struct binding_level *bl;
13320   tree current_function_parms;
13321
13322   /* Sanity check.  */
13323   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
13324   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
13325
13326   /* This should only be done once on the top most decl.  */
13327   if (have_extern_spec && !used_extern_spec)
13328     {
13329       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
13330       used_extern_spec = 1;
13331     }
13332
13333   if (flags & SF_PRE_PARSED)
13334     {
13335       decl1 = declarator;
13336
13337       fntype = TREE_TYPE (decl1);
13338       if (TREE_CODE (fntype) == METHOD_TYPE)
13339         ctype = TYPE_METHOD_BASETYPE (fntype);
13340
13341       /* ISO C++ 11.4/5.  A friend function defined in a class is in
13342          the (lexical) scope of the class in which it is defined.  */
13343       if (!ctype && DECL_FRIEND_P (decl1))
13344         {
13345           ctype = DECL_FRIEND_CONTEXT (decl1);
13346
13347           /* CTYPE could be null here if we're dealing with a template;
13348              for example, `inline friend float foo()' inside a template
13349              will have no CTYPE set.  */
13350           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13351             ctype = NULL_TREE;
13352           else
13353             doing_friend = 1;
13354         }
13355
13356       last_function_parms = DECL_ARGUMENTS (decl1);
13357       last_function_parm_tags = NULL_TREE;
13358     }
13359   else
13360     {
13361       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL_TREE);
13362       /* If the declarator is not suitable for a function definition,
13363          cause a syntax error.  */
13364       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
13365
13366       fntype = TREE_TYPE (decl1);
13367
13368       restype = TREE_TYPE (fntype);
13369       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13370         {
13371           cp_error ("semicolon missing after declaration of `%#T'", restype);
13372           shadow_tag (build_tree_list (NULL_TREE, restype));
13373           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13374           if (TREE_CODE (fntype) == FUNCTION_TYPE)
13375             fntype = build_function_type (integer_type_node,
13376                                           TYPE_ARG_TYPES (fntype));
13377           else
13378             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13379                                               integer_type_node,
13380                                               TYPE_ARG_TYPES (fntype));
13381           TREE_TYPE (decl1) = fntype;
13382         }
13383
13384       if (TREE_CODE (fntype) == METHOD_TYPE)
13385         ctype = TYPE_METHOD_BASETYPE (fntype);
13386       else if (DECL_MAIN_P (decl1))
13387         {
13388           /* If this doesn't return integer_type, complain.  */
13389           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13390             {
13391               if (pedantic || warn_return_type)
13392                 pedwarn ("return type for `main' changed to `int'");
13393               TREE_TYPE (decl1) = fntype = default_function_type;
13394             }
13395         }
13396     }
13397
13398   if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
13399     /* This is a constructor, we must ensure that any default args
13400        introduced by this definition are propagated to the clones
13401        now. The clones are used directly in overload resolution.  */
13402     adjust_clone_args (decl1);
13403
13404   /* Sometimes we don't notice that a function is a static member, and
13405      build a METHOD_TYPE for it.  Fix that up now.  */
13406   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13407       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13408     {
13409       revert_static_member_fn (decl1);
13410       last_function_parms = TREE_CHAIN (last_function_parms);
13411       ctype = NULL_TREE;
13412     }
13413
13414   /* Warn if function was previously implicitly declared
13415      (but not if we warned then).  */
13416   if (! warn_implicit
13417       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13418     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13419
13420   /* Set up current_class_type, and enter the scope of the class, if
13421      appropriate.  */
13422   if (ctype)
13423     push_nested_class (ctype, 1);
13424   else if (DECL_STATIC_FUNCTION_P (decl1))
13425     push_nested_class (DECL_CONTEXT (decl1), 2);
13426
13427   /* Now that we have entered the scope of the class, we must restore
13428      the bindings for any template parameters surrounding DECL1, if it
13429      is an inline member template.  (Order is important; consider the
13430      case where a template parameter has the same name as a field of
13431      the class.)  It is not until after this point that
13432      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
13433   if (flags & SF_INCLASS_INLINE)
13434     maybe_begin_member_template_processing (decl1);
13435
13436   /* Effective C++ rule 15.  */
13437   if (warn_ecpp
13438       && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
13439       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13440     cp_warning ("`operator=' should return a reference to `*this'");
13441
13442   /* Make the init_value nonzero so pushdecl knows this is not tentative.
13443      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
13444   if (!DECL_INITIAL (decl1))
13445     DECL_INITIAL (decl1) = error_mark_node;
13446
13447 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
13448   SET_DEFAULT_DECL_ATTRIBUTES (decl1, attrs);
13449 #endif
13450
13451   /* This function exists in static storage.
13452      (This does not mean `static' in the C sense!)  */
13453   TREE_STATIC (decl1) = 1;
13454
13455   /* We must call push_template_decl after current_class_type is set
13456      up.  (If we are processing inline definitions after exiting a
13457      class scope, current_class_type will be NULL_TREE until set above
13458      by push_nested_class.)  */
13459   if (processing_template_decl)
13460     decl1 = push_template_decl (decl1);
13461
13462   /* We are now in the scope of the function being defined.  */
13463   current_function_decl = decl1;
13464
13465   /* Save the parm names or decls from this function's declarator
13466      where store_parm_decls will find them.  */
13467   current_function_parms = last_function_parms;
13468   current_function_parm_tags = last_function_parm_tags;
13469
13470   /* Make sure the parameter and return types are reasonable.  When
13471      you declare a function, these types can be incomplete, but they
13472      must be complete when you define the function.  */
13473   if (! processing_template_decl)
13474     check_function_type (decl1, current_function_parms);
13475
13476   /* Build the return declaration for the function.  */
13477   restype = TREE_TYPE (fntype);
13478   if (!processing_template_decl)
13479     {
13480       if (!DECL_RESULT (decl1))
13481         {
13482           DECL_RESULT (decl1)
13483             = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13484           c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype),
13485                                       DECL_RESULT (decl1));
13486         }
13487     }
13488   else
13489     /* Just use `void'.  Nobody will ever look at this anyhow.  */
13490     DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, void_type_node);
13491
13492   /* Initialize RTL machinery.  We cannot do this until
13493      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
13494      even when processing a template; this is how we get
13495      CFUN set up, and our per-function variables initialized.
13496      FIXME factor out the non-RTL stuff.  */
13497   bl = current_binding_level;
13498   init_function_start (decl1, input_filename, lineno);
13499   current_binding_level = bl;
13500
13501   /* Even though we're inside a function body, we still don't want to
13502      call expand_expr to calculate the size of a variable-sized array.
13503      We haven't necessarily assigned RTL to all variables yet, so it's
13504      not safe to try to expand expressions involving them.  */
13505   immediate_size_expand = 0;
13506   cfun->x_dont_save_pending_sizes_p = 1;
13507
13508   /* Start the statement-tree, start the tree now.  */
13509   begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13510
13511   /* Let the user know we're compiling this function.  */
13512   announce_function (decl1);
13513
13514   /* Record the decl so that the function name is defined.
13515      If we already have a decl for this name, and it is a FUNCTION_DECL,
13516      use the old decl.  */
13517   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13518     {
13519       /* A specialization is not used to guide overload resolution.  */
13520       if (!DECL_TEMPLATE_SPECIALIZATION (decl1)
13521           && ! DECL_FUNCTION_MEMBER_P (decl1))
13522         decl1 = pushdecl (decl1);
13523       else
13524         {
13525           /* We need to set the DECL_CONTEXT. */
13526           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13527             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13528           /* And make sure we have enough default args.  */
13529           check_default_args (decl1);
13530         }
13531       fntype = TREE_TYPE (decl1);
13532     }
13533
13534   /* Reset these in case the call to pushdecl changed them.  */
13535   current_function_decl = decl1;
13536   cfun->decl = decl1;
13537
13538   /* If we are (erroneously) defining a function that we have already
13539      defined before, wipe out what we knew before.  */
13540   if (!DECL_PENDING_INLINE_P (decl1)
13541       && DECL_SAVED_FUNCTION_DATA (decl1))
13542     {
13543       free (DECL_SAVED_FUNCTION_DATA (decl1));
13544       DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13545     }
13546
13547   if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13548     {
13549       /* We know that this was set up by `grokclassfn'.  We do not
13550          wait until `store_parm_decls', since evil parse errors may
13551          never get us to that point.  Here we keep the consistency
13552          between `current_class_type' and `current_class_ptr'.  */
13553       tree t = DECL_ARGUMENTS (decl1);
13554
13555       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13556                           162);
13557       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13558                           19990811);
13559
13560       cp_function_chain->x_current_class_ref
13561         = build_indirect_ref (t, NULL_PTR);
13562       cp_function_chain->x_current_class_ptr = t;
13563
13564       /* Constructors and destructors need to know whether they're "in
13565          charge" of initializing virtual base classes.  */
13566       t = TREE_CHAIN (t);
13567       if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
13568         {
13569           current_in_charge_parm = t;
13570           t = TREE_CHAIN (t);
13571         }
13572       if (DECL_HAS_VTT_PARM_P (decl1))
13573         {
13574           if (DECL_NAME (t) != vtt_parm_identifier)
13575             abort ();
13576           current_vtt_parm = t;
13577         }
13578     }
13579
13580   if (DECL_INTERFACE_KNOWN (decl1))
13581     {
13582       tree ctx = decl_function_context (decl1);
13583
13584       if (DECL_NOT_REALLY_EXTERN (decl1))
13585         DECL_EXTERNAL (decl1) = 0;
13586
13587       if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx)
13588           && TREE_PUBLIC (ctx))
13589         /* This is a function in a local class in an extern inline
13590            function.  */
13591         comdat_linkage (decl1);
13592     }
13593   /* If this function belongs to an interface, it is public.
13594      If it belongs to someone else's interface, it is also external.
13595      This only affects inlines and template instantiations.  */
13596   else if (interface_unknown == 0
13597            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13598                || flag_alt_external_templates))
13599     {
13600       if (DECL_DECLARED_INLINE_P (decl1)
13601           || DECL_TEMPLATE_INSTANTIATION (decl1)
13602           || processing_template_decl)
13603         {
13604           DECL_EXTERNAL (decl1)
13605             = (interface_only
13606                || (DECL_DECLARED_INLINE_P (decl1)
13607                    && ! flag_implement_inlines
13608                    && !DECL_VINDEX (decl1)));
13609
13610           /* For WIN32 we also want to put these in linkonce sections.  */
13611           maybe_make_one_only (decl1);
13612         }
13613       else
13614         DECL_EXTERNAL (decl1) = 0;
13615       DECL_NOT_REALLY_EXTERN (decl1) = 0;
13616       DECL_INTERFACE_KNOWN (decl1) = 1;
13617     }
13618   else if (interface_unknown && interface_only
13619            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13620                || flag_alt_external_templates))
13621     {
13622       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13623          interface, we will have interface_only set but not
13624          interface_known.  In that case, we don't want to use the normal
13625          heuristics because someone will supply a #pragma implementation
13626          elsewhere, and deducing it here would produce a conflict.  */
13627       comdat_linkage (decl1);
13628       DECL_EXTERNAL (decl1) = 0;
13629       DECL_INTERFACE_KNOWN (decl1) = 1;
13630       DECL_DEFER_OUTPUT (decl1) = 1;
13631     }
13632   else
13633     {
13634       /* This is a definition, not a reference.
13635          So clear DECL_EXTERNAL.  */
13636       DECL_EXTERNAL (decl1) = 0;
13637
13638       if ((DECL_DECLARED_INLINE_P (decl1)
13639            || DECL_TEMPLATE_INSTANTIATION (decl1))
13640           && ! DECL_INTERFACE_KNOWN (decl1)
13641           /* Don't try to defer nested functions for now.  */
13642           && ! decl_function_context (decl1))
13643         DECL_DEFER_OUTPUT (decl1) = 1;
13644       else
13645         DECL_INTERFACE_KNOWN (decl1) = 1;
13646     }
13647
13648   pushlevel (0);
13649   current_binding_level->parm_flag = 1;
13650
13651   if (attrs)
13652     cplus_decl_attributes (decl1, NULL_TREE, attrs);
13653
13654   /* Promote the value to int before returning it.  */
13655   if (c_promoting_integer_type_p (restype))
13656     restype = type_promotes_to (restype);
13657
13658   if (DECL_RESULT (decl1) == NULL_TREE)
13659     {
13660       DECL_RESULT (decl1)
13661         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13662       TREE_READONLY (DECL_RESULT (decl1)) = CP_TYPE_CONST_P (restype);
13663       TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = CP_TYPE_VOLATILE_P (restype);
13664     }
13665
13666   ++function_depth;
13667
13668   if (DECL_DESTRUCTOR_P (decl1))
13669     {
13670       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13671       DECL_CONTEXT (dtor_label) = current_function_decl;
13672     }
13673
13674   store_parm_decls (current_function_parms);
13675
13676   return 1;
13677 }
13678 \f
13679 /* Store the parameter declarations into the current function declaration.
13680    This is called after parsing the parameter declarations, before
13681    digesting the body of the function.
13682
13683    Also install to binding contour return value identifier, if any.  */
13684
13685 static void
13686 store_parm_decls (current_function_parms)
13687      tree current_function_parms;
13688 {
13689   register tree fndecl = current_function_decl;
13690   register tree parm;
13691   int parms_have_cleanups = 0;
13692   tree cleanups = NULL_TREE;
13693
13694   /* This is a list of types declared among parms in a prototype.  */
13695   tree parmtags = current_function_parm_tags;
13696
13697   /* This is a chain of any other decls that came in among the parm
13698      declarations.  If a parm is declared with  enum {foo, bar} x;
13699      then CONST_DECLs for foo and bar are put here.  */
13700   tree nonparms = NULL_TREE;
13701
13702   if (current_function_parms)
13703     {
13704       /* This case is when the function was defined with an ANSI prototype.
13705          The parms already have decls, so we need not do anything here
13706          except record them as in effect
13707          and complain if any redundant old-style parm decls were written.  */
13708
13709       tree specparms = current_function_parms;
13710       tree next;
13711
13712       /* Must clear this because it might contain TYPE_DECLs declared
13713              at class level.  */
13714       storedecls (NULL_TREE);
13715
13716       /* If we're doing semantic analysis, then we'll call pushdecl
13717              for each of these.  We must do them in reverse order so that
13718              they end in the correct forward order.  */
13719       specparms = nreverse (specparms);
13720
13721       for (parm = specparms; parm; parm = next)
13722         {
13723           next = TREE_CHAIN (parm);
13724           if (TREE_CODE (parm) == PARM_DECL)
13725             {
13726               tree cleanup;
13727
13728               if (DECL_NAME (parm) == NULL_TREE
13729                   || TREE_CODE (parm) != VOID_TYPE)
13730                 pushdecl (parm);
13731               else
13732                 cp_error ("parameter `%D' declared void", parm);
13733
13734               cleanup = (processing_template_decl
13735                          ? NULL_TREE
13736                          : maybe_build_cleanup (parm));
13737
13738               if (cleanup)
13739                 cleanups = tree_cons (parm, cleanup, cleanups);
13740             }
13741           else
13742             {
13743               /* If we find an enum constant or a type tag,
13744                  put it aside for the moment.  */
13745               TREE_CHAIN (parm) = NULL_TREE;
13746               nonparms = chainon (nonparms, parm);
13747             }
13748         }
13749
13750       /* Get the decls in their original chain order and record in the
13751          function.  This is all and only the PARM_DECLs that were
13752          pushed into scope by the loop above.  */
13753       DECL_ARGUMENTS (fndecl) = getdecls ();
13754       storetags (chainon (parmtags, gettags ()));
13755     }
13756   else
13757     DECL_ARGUMENTS (fndecl) = NULL_TREE;
13758
13759   /* Now store the final chain of decls for the arguments
13760      as the decl-chain of the current lexical scope.
13761      Put the enumerators in as well, at the front so that
13762      DECL_ARGUMENTS is not modified.  */
13763   storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
13764
13765   /* Now that we have initialized the parms, we can start their
13766      cleanups.  We cannot do this before, since expand_decl_cleanup
13767      should not be called before the parm can be used.  */
13768   while (cleanups)
13769     {
13770       finish_decl_cleanup (TREE_PURPOSE (cleanups),
13771                            TREE_VALUE (cleanups));
13772       cleanups = TREE_CHAIN (cleanups);
13773     }
13774
13775   /* Create a binding contour which can be used to catch
13776      cleanup-generated temporaries.  */
13777   if (parms_have_cleanups)
13778     pushlevel (0);
13779
13780   /* Do the starting of the exception specifications, if we have any.  */
13781   if (flag_exceptions && !processing_template_decl
13782       && flag_enforce_eh_specs
13783       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13784     current_eh_spec_block = begin_eh_spec_block ();
13785 }
13786
13787 \f
13788 /* We have finished doing semantic analysis on DECL, but have not yet
13789    generated RTL for its body.  Save away our current state, so that
13790    when we want to generate RTL later we know what to do.  */
13791
13792 static void
13793 save_function_data (decl)
13794      tree decl;
13795 {
13796   struct cp_language_function *f;
13797
13798   /* Save the language-specific per-function data so that we can
13799      get it back when we really expand this function.  */
13800   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
13801                       19990908);
13802
13803   /* Make a copy.  */
13804   f = ((struct cp_language_function *)
13805        xmalloc (sizeof (struct cp_language_function)));
13806   memcpy (f, cp_function_chain, sizeof (struct cp_language_function));
13807   DECL_SAVED_FUNCTION_DATA (decl) = f;
13808
13809   /* Clear out the bits we don't need.  */
13810   f->base.x_stmt_tree.x_last_stmt = NULL_TREE;
13811   f->base.x_stmt_tree.x_last_expr_type = NULL_TREE;
13812   f->x_named_label_uses = NULL;
13813   f->bindings = NULL;
13814   f->x_local_names = NULL;
13815
13816   /* When we get back here again, we will be expanding.  */
13817   f->x_expanding_p = 1;
13818
13819   /* If we've already decided that we cannot inline this function, we
13820      must remember that fact when we actually go to expand the
13821      function.  */
13822   if (current_function_cannot_inline)
13823     {
13824       f->cannot_inline = current_function_cannot_inline;
13825       DECL_INLINE (decl) = 0;
13826     }
13827 }
13828
13829 /* At the end of every constructor we generate to code to return
13830    `this'.  Do that now.  */
13831
13832 static void
13833 finish_constructor_body ()
13834 {
13835   /* Any return from a constructor will end up here.  */
13836   if (ctor_label)
13837     add_stmt (build_stmt (LABEL_STMT, ctor_label));
13838
13839   /* Clear CTOR_LABEL so that finish_return_stmt knows to really
13840      generate the return, rather than a goto to CTOR_LABEL.  */
13841   ctor_label = NULL_TREE;
13842   /* In check_return_expr we translate an empty return from a
13843      constructor to a return of `this'.  */
13844   finish_return_stmt (NULL_TREE);
13845   /* Mark the end of the constructor.  */
13846   add_stmt (build_stmt (CTOR_STMT));
13847 }
13848
13849 /* At the end of every destructor we generate code to restore virtual
13850    function tables to the values desired by base classes and to call
13851    to base class destructors.  Do that now.  */
13852
13853 static void
13854 finish_destructor_body ()
13855 {
13856   tree compound_stmt;
13857   tree exprstmt;
13858
13859   /* Create a block to contain all the extra code.  */
13860   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
13861
13862   /* Any return from a destructor will end up here.  */
13863   add_stmt (build_stmt (LABEL_STMT, dtor_label));
13864
13865   /* Generate the code to call destructor on base class.  If this
13866      destructor belongs to a class with virtual functions, then set
13867      the virtual function table pointer to represent the type of our
13868      base class.  */
13869
13870   /* This side-effect makes call to `build_delete' generate the code
13871      we have to have at the end of this destructor.  `build_delete'
13872      will set the flag again.  */
13873   TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
13874
13875   exprstmt = build_delete (current_class_type,
13876                            current_class_ref,
13877                            sfk_base_destructor,
13878                            LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
13879                            0);
13880
13881   if (exprstmt != error_mark_node
13882       && (TREE_CODE (exprstmt) != NOP_EXPR
13883           || TREE_OPERAND (exprstmt, 0) != integer_zero_node
13884           || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
13885     {
13886       if (exprstmt != void_zero_node)
13887         /* Don't call `expand_expr_stmt' if we're not going to do
13888            anything, since -Wall will give a diagnostic.  */
13889         finish_expr_stmt (exprstmt);
13890
13891       /* Run destructors for all virtual baseclasses.  */
13892       if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
13893         {
13894           tree vbases;
13895           tree if_stmt;
13896
13897           if_stmt = begin_if_stmt ();
13898           finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
13899                                       current_in_charge_parm,
13900                                       integer_two_node),
13901                                if_stmt);
13902
13903           vbases = CLASSTYPE_VBASECLASSES (current_class_type);
13904           /* The CLASSTYPE_VBASECLASSES list is in initialization
13905              order, so we have to march through it in reverse order.  */
13906           for (vbases = nreverse (copy_list (vbases));
13907                vbases;
13908                vbases = TREE_CHAIN (vbases))
13909             {
13910               tree vbase = TREE_VALUE (vbases);
13911               tree base_type = BINFO_TYPE (vbase);
13912
13913               if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (base_type))
13914                 {
13915                   tree base_ptr_type = build_pointer_type (base_type);
13916                   tree expr = current_class_ptr;
13917
13918                   /* Convert to the basetype here, as we know the layout is
13919                      fixed. What is more, if we let build_method_call do it,
13920                      it will use the vtable, which may have been clobbered
13921                      by the deletion of our primary base.  */
13922
13923                   expr = build1 (NOP_EXPR, base_ptr_type, expr);
13924                   expr = build (PLUS_EXPR, base_ptr_type, expr,
13925                                 BINFO_OFFSET (vbase));
13926                   expr = build_indirect_ref (expr, NULL);
13927                   expr = build_method_call (expr, base_dtor_identifier,
13928                                             NULL_TREE, vbase,
13929                                             LOOKUP_NORMAL);
13930                   finish_expr_stmt (expr);
13931                 }
13932             }
13933
13934           finish_then_clause (if_stmt);
13935           finish_if_stmt ();
13936         }
13937     }
13938
13939   /* In a virtual destructor, we must call delete.  */
13940   if (DECL_VIRTUAL_P (current_function_decl))
13941     {
13942       tree if_stmt;
13943       tree virtual_size = c_sizeof (current_class_type);
13944
13945       /* [class.dtor]
13946
13947          At the point of definition of a virtual destructor (including
13948          an implicit definition), non-placement operator delete shall
13949          be looked up in the scope of the destructor's class and if
13950          found shall be accessible and unambiguous.  */
13951       exprstmt = build_op_delete_call
13952         (DELETE_EXPR, current_class_ptr, virtual_size,
13953          LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
13954
13955       if_stmt = begin_if_stmt ();
13956       finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
13957                                   current_in_charge_parm,
13958                                   integer_one_node),
13959                            if_stmt);
13960       finish_expr_stmt (exprstmt);
13961       finish_then_clause (if_stmt);
13962       finish_if_stmt ();
13963     }
13964
13965   /* Close the block we started above.  */
13966   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
13967 }
13968
13969 /* Finish up a function declaration and compile that function
13970    all the way to assembler language output.  The free the storage
13971    for the function definition.
13972
13973    FLAGS is a bitwise or of the following values:
13974      1 - CALL_POPLEVEL
13975        An extra call to poplevel (and expand_end_bindings) must be
13976        made to take care of the binding contour for the base
13977        initializers.  This is only relevant for constructors.
13978      2 - INCLASS_INLINE
13979        We just finished processing the body of an in-class inline
13980        function definition.  (This processing will have taken place
13981        after the class definition is complete.)  */
13982
13983 tree
13984 finish_function (flags)
13985      int flags;
13986 {
13987   register tree fndecl = current_function_decl;
13988   tree fntype, ctype = NULL_TREE;
13989   int call_poplevel = (flags & 1) != 0;
13990   int inclass_inline = (flags & 2) != 0;
13991   int nested;
13992
13993   /* When we get some parse errors, we can end up without a
13994      current_function_decl, so cope.  */
13995   if (fndecl == NULL_TREE)
13996     return error_mark_node;
13997
13998   nested = function_depth > 1;
13999   fntype = TREE_TYPE (fndecl);
14000
14001   /*  TREE_READONLY (fndecl) = 1;
14002       This caused &foo to be of type ptr-to-const-function
14003       which then got a warning when stored in a ptr-to-function variable.  */
14004
14005   my_friendly_assert (building_stmt_tree (), 20000911);
14006
14007   /* For a cloned function, we've already got all the code we need;
14008      there's no need to add any extra bits.  */
14009   if (!DECL_CLONED_FUNCTION_P (fndecl))
14010     {
14011       if (DECL_CONSTRUCTOR_P (fndecl))
14012         {
14013           finish_constructor_body ();
14014           if (call_poplevel)
14015             do_poplevel ();
14016         }
14017       else if (DECL_DESTRUCTOR_P (fndecl) && !processing_template_decl)
14018         finish_destructor_body ();
14019       else if (DECL_MAIN_P (fndecl))
14020         {
14021           /* Make it so that `main' always returns 0 by default.  */
14022 #ifdef VMS
14023           finish_return_stmt (integer_one_node);
14024 #else
14025           finish_return_stmt (integer_zero_node);
14026 #endif
14027         }
14028
14029       /* Finish dealing with exception specifiers.  */
14030       if (flag_exceptions && !processing_template_decl
14031           && flag_enforce_eh_specs
14032           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14033         finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
14034                               (TREE_TYPE (current_function_decl)),
14035                               current_eh_spec_block);
14036     }
14037
14038   /* If we're saving up tree structure, tie off the function now.  */
14039   finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
14040
14041   /* This must come after expand_function_end because cleanups might
14042      have declarations (from inline functions) that need to go into
14043      this function's blocks.  */
14044   if (current_binding_level->parm_flag != 1)
14045     my_friendly_abort (122);
14046   poplevel (1, 0, 1);
14047
14048   /* Remember that we were in class scope.  */
14049   if (current_class_name)
14050     ctype = current_class_type;
14051
14052   /* Must mark the RESULT_DECL as being in this function.  */
14053   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
14054
14055   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14056      to the FUNCTION_DECL node itself.  */
14057   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
14058
14059   /* Save away current state, if appropriate.  */
14060   if (!processing_template_decl)
14061     save_function_data (fndecl);
14062
14063   /* If this function calls `setjmp' it cannot be inlined.  When
14064      `longjmp' is called it is not guaranteed to restore the value of
14065      local variables that have been modified since the call to
14066      `setjmp'.  So, if were to inline this function into some caller
14067      `c', then when we `longjmp', we might not restore all variables
14068      in `c'.  (It might seem, at first blush, that there's no way for
14069      this function to modify local variables in `c', but their
14070      addresses may have been stored somewhere accessible to this
14071      function.)  */
14072   if (!processing_template_decl && calls_setjmp_p (fndecl))
14073     DECL_UNINLINABLE (fndecl) = 1;
14074
14075   /* Clear out memory we no longer need.  */
14076   free_after_parsing (cfun);
14077   /* Since we never call rest_of_compilation, we never clear
14078      CFUN.  Do so explicitly.  */
14079   free_after_compilation (cfun);
14080   cfun = NULL;
14081
14082   /* If this is a in-class inline definition, we may have to pop the
14083      bindings for the template parameters that we added in
14084      maybe_begin_member_template_processing when start_function was
14085      called.  */
14086   if (inclass_inline)
14087     maybe_end_member_template_processing ();
14088
14089   /* Leave the scope of the class.  */
14090   if (ctype)
14091     pop_nested_class ();
14092
14093   --function_depth;
14094
14095   /* Clean up.  */
14096   if (! nested)
14097     /* Let the error reporting routines know that we're outside a
14098        function.  For a nested function, this value is used in
14099        pop_cp_function_context and then reset via pop_function_context.  */
14100     current_function_decl = NULL_TREE;
14101
14102   return fndecl;
14103 }
14104 \f
14105 /* Create the FUNCTION_DECL for a function definition.
14106    DECLSPECS and DECLARATOR are the parts of the declaration;
14107    they describe the return type and the name of the function,
14108    but twisted together in a fashion that parallels the syntax of C.
14109
14110    This function creates a binding context for the function body
14111    as well as setting up the FUNCTION_DECL in current_function_decl.
14112
14113    Returns a FUNCTION_DECL on success.
14114
14115    If the DECLARATOR is not suitable for a function (it defines a datum
14116    instead), we return 0, which tells yyparse to report a parse error.
14117
14118    May return void_type_node indicating that this method is actually
14119    a friend.  See grokfield for more details.
14120
14121    Came here with a `.pushlevel' .
14122
14123    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14124    CHANGES TO CODE IN `grokfield'.  */
14125
14126 tree
14127 start_method (declspecs, declarator, attrlist)
14128      tree declarator, declspecs, attrlist;
14129 {
14130   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14131                                 attrlist);
14132
14133   /* Something too ugly to handle.  */
14134   if (fndecl == NULL_TREE)
14135     return NULL_TREE;
14136
14137   /* Pass friends other than inline friend functions back.  */
14138   if (fndecl == void_type_node)
14139     return fndecl;
14140
14141   if (TREE_CODE (fndecl) != FUNCTION_DECL)
14142     /* Not a function, tell parser to report parse error.  */
14143     return NULL_TREE;
14144
14145   if (DECL_IN_AGGR_P (fndecl))
14146     {
14147       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14148         {
14149           if (DECL_CONTEXT (fndecl)
14150               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14151             cp_error ("`%D' is already defined in class `%T'", fndecl,
14152                       DECL_CONTEXT (fndecl));
14153         }
14154       return void_type_node;
14155     }
14156
14157   check_template_shadow (fndecl);
14158
14159   DECL_DECLARED_INLINE_P (fndecl) = 1;
14160
14161   if (flag_default_inline)
14162     DECL_INLINE (fndecl) = 1;
14163
14164   /* We process method specializations in finish_struct_1.  */
14165   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14166     fndecl = push_template_decl (fndecl);
14167
14168   if (! DECL_FRIEND_P (fndecl))
14169     {
14170       if (TREE_CHAIN (fndecl))
14171         {
14172           fndecl = copy_node (fndecl);
14173           TREE_CHAIN (fndecl) = NULL_TREE;
14174         }
14175
14176       if (DECL_CONSTRUCTOR_P (fndecl))
14177         {
14178           if (! grok_ctor_properties (current_class_type, fndecl))
14179             return void_type_node;
14180         }
14181       else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl)))
14182         grok_op_properties (fndecl, DECL_VIRTUAL_P (fndecl), 0);
14183     }
14184
14185   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14186
14187   /* Make a place for the parms */
14188   pushlevel (0);
14189   current_binding_level->parm_flag = 1;
14190
14191   DECL_IN_AGGR_P (fndecl) = 1;
14192   return fndecl;
14193 }
14194
14195 /* Go through the motions of finishing a function definition.
14196    We don't compile this method until after the whole class has
14197    been processed.
14198
14199    FINISH_METHOD must return something that looks as though it
14200    came from GROKFIELD (since we are defining a method, after all).
14201
14202    This is called after parsing the body of the function definition.
14203    STMTS is the chain of statements that makes up the function body.
14204
14205    DECL is the ..._DECL that `start_method' provided.  */
14206
14207 tree
14208 finish_method (decl)
14209      tree decl;
14210 {
14211   register tree fndecl = decl;
14212   tree old_initial;
14213
14214   register tree link;
14215
14216   if (decl == void_type_node)
14217     return decl;
14218
14219   old_initial = DECL_INITIAL (fndecl);
14220
14221   /* Undo the level for the parms (from start_method).
14222      This is like poplevel, but it causes nothing to be
14223      saved.  Saving information here confuses symbol-table
14224      output routines.  Besides, this information will
14225      be correctly output when this method is actually
14226      compiled.  */
14227
14228   /* Clear out the meanings of the local variables of this level;
14229      also record in each decl which block it belongs to.  */
14230
14231   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14232     {
14233       if (DECL_NAME (link) != NULL_TREE)
14234         pop_binding (DECL_NAME (link), link);
14235       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14236       DECL_CONTEXT (link) = NULL_TREE;
14237     }
14238
14239   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
14240                       (HOST_WIDE_INT) current_binding_level->level_chain,
14241                       current_binding_level->parm_flag,
14242                       current_binding_level->keep);
14243
14244   poplevel (0, 0, 0);
14245
14246   DECL_INITIAL (fndecl) = old_initial;
14247
14248   /* We used to check if the context of FNDECL was different from
14249      current_class_type as another way to get inside here.  This didn't work
14250      for String.cc in libg++.  */
14251   if (DECL_FRIEND_P (fndecl))
14252     {
14253       CLASSTYPE_INLINE_FRIENDS (current_class_type)
14254         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14255       decl = void_type_node;
14256     }
14257
14258   return decl;
14259 }
14260 \f
14261 /* Called when a new struct TYPE is defined.
14262    If this structure or union completes the type of any previous
14263    variable declaration, lay it out and output its rtl.  */
14264
14265 void
14266 hack_incomplete_structures (type)
14267      tree type;
14268 {
14269   tree *list;
14270   struct binding_level *level;
14271
14272   if (!type) /* Don't do this for class templates.  */
14273     return;
14274
14275   if (namespace_bindings_p ())
14276     {
14277       level = 0;
14278       list = &namespace_scope_incomplete;
14279     }
14280   else
14281     {
14282       level = innermost_nonclass_level ();
14283       list = &level->incomplete;
14284     }
14285
14286   while (1)
14287     {
14288       while (*list)
14289         {
14290           tree decl = TREE_VALUE (*list);
14291           if ((decl && TREE_TYPE (decl) == type)
14292               || (TREE_TYPE (decl)
14293                   && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14294                   && TREE_TYPE (TREE_TYPE (decl)) == type))
14295             {
14296               int toplevel = toplevel_bindings_p ();
14297               if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14298                   && TREE_TYPE (TREE_TYPE (decl)) == type)
14299                 layout_type (TREE_TYPE (decl));
14300               layout_decl (decl, 0);
14301               rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
14302               if (! toplevel)
14303                 {
14304                   tree cleanup;
14305                   expand_decl (decl);
14306                   cleanup = maybe_build_cleanup (decl);
14307                   expand_decl_init (decl);
14308                   if (! expand_decl_cleanup (decl, cleanup))
14309                     cp_error ("parser lost in parsing declaration of `%D'",
14310                               decl);
14311                 }
14312               *list = TREE_CHAIN (*list);
14313             }
14314           else
14315             list = &TREE_CHAIN (*list);
14316         }
14317
14318       /* Keep looking through artificial binding levels generated
14319          for local variables.  */
14320       if (level && level->keep == 2)
14321         {
14322           level = level->level_chain;
14323           list = &level->incomplete;
14324         }
14325       else
14326         break;
14327     }
14328 }
14329
14330 /* If DECL is of a type which needs a cleanup, build that cleanup
14331    here.  */
14332
14333 tree
14334 maybe_build_cleanup (decl)
14335      tree decl;
14336 {
14337   tree type = TREE_TYPE (decl);
14338
14339   if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14340     {
14341       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14342       tree rval;
14343
14344       if (TREE_CODE (type) == ARRAY_TYPE)
14345         rval = decl;
14346       else
14347         {
14348           mark_addressable (decl);
14349           rval = build_unary_op (ADDR_EXPR, decl, 0);
14350         }
14351
14352       /* Optimize for space over speed here.  */
14353       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14354           || flag_expensive_optimizations)
14355         flags |= LOOKUP_NONVIRTUAL;
14356
14357       rval = build_delete (TREE_TYPE (rval), rval,
14358                            sfk_complete_destructor, flags, 0);
14359
14360       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14361           && ! TYPE_HAS_DESTRUCTOR (type))
14362         rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14363                                                build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14364
14365       return rval;
14366     }
14367   return 0;
14368 }
14369 \f
14370 /* When a stmt has been parsed, this function is called.  */
14371
14372 void
14373 finish_stmt ()
14374 {
14375   /* Always assume this statement was not an expression statement.  If
14376      it actually was an expression statement, its our callers
14377      responsibility to fix this up.  */
14378   last_expr_type = NULL_TREE;
14379 }
14380
14381 /* DECL was originally constructed as a non-static member function,
14382    but turned out to be static.  Update it accordingly.  */
14383
14384 void
14385 revert_static_member_fn (decl)
14386      tree decl;
14387 {
14388   tree tmp;
14389   tree function = TREE_TYPE (decl);
14390   tree args = TYPE_ARG_TYPES (function);
14391
14392   if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args)))
14393       != TYPE_UNQUALIFIED)
14394     cp_error ("static member function `%#D' declared with type qualifiers",
14395               decl);
14396
14397   args = TREE_CHAIN (args);
14398   tmp = build_function_type (TREE_TYPE (function), args);
14399   tmp = build_qualified_type (tmp, CP_TYPE_QUALS (function));
14400   tmp = build_exception_variant (tmp,
14401                                  TYPE_RAISES_EXCEPTIONS (function));
14402   TREE_TYPE (decl) = tmp;
14403   if (DECL_ARGUMENTS (decl))
14404     DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
14405   DECL_STATIC_FUNCTION_P (decl) = 1;
14406 }
14407
14408 /* Initialize the variables used during compilation of a C++
14409    function.  */
14410
14411 static void
14412 push_cp_function_context (f)
14413      struct function *f;
14414 {
14415   struct cp_language_function *p
14416     = ((struct cp_language_function *)
14417        xcalloc (1, sizeof (struct cp_language_function)));
14418   f->language = (struct language_function *) p;
14419
14420   /* It takes an explicit call to expand_body to generate RTL for a
14421      function.  */
14422   expanding_p = 0;
14423
14424   /* Whenever we start a new function, we destroy temporaries in the
14425      usual way.  */
14426   current_stmt_tree ()->stmts_are_full_exprs_p = 1;
14427 }
14428
14429 /* Free the language-specific parts of F, now that we've finished
14430    compiling the function.  */
14431
14432 static void
14433 pop_cp_function_context (f)
14434      struct function *f;
14435 {
14436   if (f->language)
14437     {
14438       struct cp_language_function *cp =
14439         (struct cp_language_function *) f->language;
14440       if (cp->x_local_names)
14441         VARRAY_FREE (cp->x_local_names);
14442       free (f->language);
14443     }
14444   f->language = 0;
14445 }
14446
14447 /* Mark P for GC.  */
14448
14449 static void
14450 mark_lang_function (p)
14451      struct cp_language_function *p;
14452 {
14453   if (!p)
14454     return;
14455
14456   mark_c_language_function (&p->base);
14457
14458   ggc_mark_tree (p->x_ctor_label);
14459   ggc_mark_tree (p->x_dtor_label);
14460   ggc_mark_tree (p->x_current_class_ptr);
14461   ggc_mark_tree (p->x_current_class_ref);
14462   ggc_mark_tree (p->x_eh_spec_block);
14463   ggc_mark_tree_varray (p->x_local_names);
14464
14465   mark_named_label_lists (&p->x_named_labels, &p->x_named_label_uses);
14466   mark_binding_level (&p->bindings);
14467 }
14468
14469 /* Mark the language-specific data in F for GC.  */
14470
14471 static void
14472 mark_cp_function_context (f)
14473      struct function *f;
14474 {
14475   mark_lang_function ((struct cp_language_function *) f->language);
14476 }
14477
14478 void
14479 lang_mark_tree (t)
14480      tree t;
14481 {
14482   enum tree_code code = TREE_CODE (t);
14483   if (code == IDENTIFIER_NODE)
14484     {
14485       struct lang_identifier *li = (struct lang_identifier *) t;
14486       struct lang_id2 *li2 = li->x;
14487       ggc_mark_tree (li->namespace_bindings);
14488       ggc_mark_tree (li->bindings);
14489       ggc_mark_tree (li->class_value);
14490       ggc_mark_tree (li->class_template_info);
14491
14492       if (li2)
14493         {
14494           ggc_mark_tree (li2->label_value);
14495           ggc_mark_tree (li2->implicit_decl);
14496           ggc_mark_tree (li2->error_locus);
14497         }
14498     }
14499   else if (code == CPLUS_BINDING)
14500     {
14501       if (BINDING_HAS_LEVEL_P (t))
14502         mark_binding_level (&BINDING_LEVEL (t));
14503       else
14504         ggc_mark_tree (BINDING_SCOPE (t));
14505       ggc_mark_tree (BINDING_VALUE (t));
14506     }
14507   else if (code == OVERLOAD)
14508     ggc_mark_tree (OVL_FUNCTION (t));
14509   else if (code == TEMPLATE_PARM_INDEX)
14510     ggc_mark_tree (TEMPLATE_PARM_DECL (t));
14511   else if (TREE_CODE_CLASS (code) == 'd')
14512     {
14513       struct lang_decl *ld = DECL_LANG_SPECIFIC (t);
14514
14515       if (ld)
14516         {
14517           ggc_mark (ld);
14518           c_mark_lang_decl (&ld->decl_flags.base);
14519           if (!DECL_GLOBAL_CTOR_P (t)
14520               && !DECL_GLOBAL_DTOR_P (t)
14521               && !DECL_THUNK_P (t)
14522               && !DECL_DISCRIMINATOR_P (t))
14523             ggc_mark_tree (ld->decl_flags.u2.access);
14524           else if (DECL_THUNK_P (t))
14525             ggc_mark_tree (ld->decl_flags.u2.vcall_offset);
14526           if (TREE_CODE (t) != NAMESPACE_DECL)
14527             ggc_mark_tree (ld->decl_flags.u.template_info);
14528           else
14529             mark_binding_level (&NAMESPACE_LEVEL (t));
14530           if (CAN_HAVE_FULL_LANG_DECL_P (t))
14531             {
14532               ggc_mark_tree (ld->befriending_classes);
14533               ggc_mark_tree (ld->context);
14534               ggc_mark_tree (ld->cloned_function);
14535               ggc_mark_tree (ld->inlined_fns);
14536               if (TREE_CODE (t) == TYPE_DECL)
14537                 ggc_mark_tree (ld->u.sorted_fields);
14538               else if (TREE_CODE (t) == FUNCTION_DECL
14539                        && !DECL_PENDING_INLINE_P (t))
14540                 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t));
14541             }
14542         }
14543     }
14544   else if (TREE_CODE_CLASS (code) == 't')
14545     {
14546       struct lang_type *lt = TYPE_LANG_SPECIFIC (t);
14547
14548       if (lt && !(TREE_CODE (t) == POINTER_TYPE
14549                   && TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE))
14550         {
14551           ggc_mark (lt);
14552           ggc_mark_tree (lt->primary_base);
14553           ggc_mark_tree (lt->vfields);
14554           ggc_mark_tree (lt->vbases);
14555           ggc_mark_tree (lt->tags);
14556           ggc_mark_tree (lt->size);
14557           ggc_mark_tree (lt->pure_virtuals);
14558           ggc_mark_tree (lt->friend_classes);
14559           ggc_mark_tree (lt->rtti);
14560           ggc_mark_tree (lt->methods);
14561           ggc_mark_tree (lt->template_info);
14562           ggc_mark_tree (lt->befriending_classes);
14563         }
14564       else if (lt)
14565         /* In the case of pointer-to-member function types, the
14566            TYPE_LANG_SPECIFIC is really just a tree.  */
14567         ggc_mark_tree ((tree) lt);
14568     }
14569 }
14570
14571 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
14572    the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++.  */
14573
14574 tree
14575 identifier_global_value (t)
14576      tree t;
14577 {
14578   return IDENTIFIER_GLOBAL_VALUE (t);
14579 }
14580
14581 /* Build the void_list_node (void_type_node having been created).  */
14582 tree
14583 build_void_list_node ()
14584 {
14585   tree t = build_tree_list (NULL_TREE, void_type_node);
14586   TREE_PARMLIST (t) = 1;
14587   return t;
14588 }
14589
14590 static int
14591 cp_missing_noreturn_ok_p (decl)
14592      tree decl;
14593 {
14594   /* A missing noreturn is ok for the `main' function.  */
14595   return DECL_MAIN_P (decl);
14596 }